repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
null |
wildfly-main/clustering/singleton/extension/src/main/java/org/wildfly/extension/clustering/singleton/deployment/SingletonDeploymentConfiguration.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.singleton.deployment;
/**
* Configuration of a singleton deployment.
* @author Paul Ferraro
*/
public interface SingletonDeploymentConfiguration {
String getPolicy();
}
| 1,244
| 35.617647
| 70
|
java
|
null |
wildfly-main/clustering/singleton/extension/src/main/java/org/wildfly/extension/clustering/singleton/deployment/SingletonDeploymentSchema.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.singleton.deployment;
import java.util.List;
import javax.xml.stream.XMLStreamException;
import org.jboss.as.controller.xml.IntVersionSchema;
import org.jboss.as.controller.xml.VersionedNamespace;
import org.jboss.as.controller.xml.XMLElementSchema;
import org.jboss.as.server.deployment.DeploymentUnit;
import org.jboss.as.server.deployment.jbossallxml.JBossAllSchema;
import org.jboss.staxmapper.IntVersion;
import org.jboss.staxmapper.XMLExtendedStreamReader;
/**
* Enumerates the singleton deployment configuration schemas.
* @author Paul Ferraro
*/
public enum SingletonDeploymentSchema implements XMLElementSchema<SingletonDeploymentSchema, MutableSingletonDeploymentConfiguration>, JBossAllSchema<SingletonDeploymentSchema, SingletonDeploymentConfiguration> {
VERSION_1_0(1, 0),
;
public static final SingletonDeploymentSchema CURRENT = VERSION_1_0;
private final VersionedNamespace<IntVersion, SingletonDeploymentSchema> namespace;
SingletonDeploymentSchema(int major, int minor) {
this.namespace = IntVersionSchema.createURN(List.of(IntVersionSchema.JBOSS_IDENTIFIER, this.getLocalName()), new IntVersion(major, minor));
}
@Override
public String getLocalName() {
return "singleton-deployment";
}
@Override
public VersionedNamespace<IntVersion, SingletonDeploymentSchema> getNamespace() {
return this.namespace;
}
@Override
public void readElement(XMLExtendedStreamReader reader, MutableSingletonDeploymentConfiguration configuration) throws XMLStreamException {
new SingletonDeploymentXMLReader(this).readElement(reader, configuration);
}
@Override
public SingletonDeploymentConfiguration parse(XMLExtendedStreamReader reader, DeploymentUnit unit) throws XMLStreamException {
MutableSingletonDeploymentConfiguration configuration = new MutableSingletonDeploymentConfiguration(unit);
this.readElement(reader, configuration);
return configuration;
}
}
| 3,067
| 39.906667
| 212
|
java
|
null |
wildfly-main/clustering/singleton/extension/src/main/java/org/wildfly/extension/clustering/singleton/deployment/SingletonDeploymentProcessor.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.singleton.deployment;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.as.server.deployment.AttachmentKey;
import org.jboss.as.server.deployment.Attachments;
import org.jboss.as.server.deployment.DeploymentPhaseContext;
import org.jboss.as.server.deployment.DeploymentUnit;
import org.jboss.as.server.deployment.DeploymentUnitProcessingException;
import org.jboss.as.server.deployment.DeploymentUnitProcessor;
import org.jboss.msc.service.LifecycleEvent;
import org.jboss.msc.service.LifecycleListener;
import org.jboss.msc.service.ServiceController;
import org.jboss.msc.service.ServiceController.Mode;
import org.wildfly.clustering.singleton.SingletonPolicy;
import org.wildfly.extension.clustering.singleton.SingletonLogger;
/**
* DUP that attaches the singleton DeploymentUnitPhaseBuilder if a deployment policy is attached.
* @author Paul Ferraro
*/
@SuppressWarnings("removal")
public class SingletonDeploymentProcessor implements DeploymentUnitProcessor, LifecycleListener {
public static final AttachmentKey<SingletonPolicy> POLICY_KEY = AttachmentKey.create(SingletonPolicy.class);
@Override
public void deploy(DeploymentPhaseContext context) throws DeploymentUnitProcessingException {
DeploymentUnit unit = context.getDeploymentUnit();
if (unit.getParent() == null) {
SingletonPolicy policy = context.getAttachment(POLICY_KEY);
if (policy != null) {
CapabilityServiceSupport support = unit.getAttachment(Attachments.CAPABILITY_SERVICE_SUPPORT);
// Ideally, we would just install the next phase using the singleton policy, however deployment unit phases do not currently support restarts
// Restart the deployment using the attached phase builder, but only if a builder was not already attached
if (unit.putAttachment(Attachments.DEPLOYMENT_UNIT_PHASE_BUILDER, new SingletonDeploymentUnitPhaseBuilder(support, policy)) == null) {
SingletonLogger.ROOT_LOGGER.singletonDeploymentDetected(policy);
ServiceController<?> controller = context.getServiceRegistry().getRequiredService(unit.getServiceName());
controller.addListener(this);
controller.setMode(Mode.NEVER);
}
}
}
}
@Override
public void handleEvent(ServiceController<?> controller, LifecycleEvent event) {
if (event == LifecycleEvent.DOWN) {
controller.setMode(Mode.ACTIVE);
controller.removeListener(this);
}
}
}
| 3,676
| 48.026667
| 157
|
java
|
null |
wildfly-main/clustering/singleton/extension/src/main/java/org/wildfly/extension/clustering/singleton/deployment/SingletonDeploymentParsingProcessor.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.singleton.deployment;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.EnumSet;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import org.jboss.as.controller.xml.XMLElementSchema;
import org.jboss.as.server.deployment.Attachments;
import org.jboss.as.server.deployment.DeploymentPhaseContext;
import org.jboss.as.server.deployment.DeploymentUnit;
import org.jboss.as.server.deployment.DeploymentUnitProcessingException;
import org.jboss.as.server.deployment.DeploymentUnitProcessor;
import org.jboss.as.server.logging.ServerLogger;
import org.jboss.staxmapper.XMLMapper;
import org.jboss.vfs.VirtualFile;
/**
* Parses a deployment descriptor defining the singleton deployment policy.
* @author Paul Ferraro
*/
public class SingletonDeploymentParsingProcessor implements DeploymentUnitProcessor {
private static final String SINGLETON_DEPLOYMENT_DESCRIPTOR = "META-INF/singleton-deployment.xml";
private static final XMLInputFactory XML_INPUT_FACTORY = XMLInputFactory.newInstance();
private final XMLMapper mapper = XMLElementSchema.createXMLMapper(EnumSet.allOf(SingletonDeploymentSchema.class));
@Override
public void deploy(DeploymentPhaseContext context) throws DeploymentUnitProcessingException {
DeploymentUnit unit = context.getDeploymentUnit();
if (!unit.hasAttachment(SingletonDeploymentDependencyProcessor.CONFIGURATION_KEY)) {
VirtualFile file = unit.getAttachment(Attachments.DEPLOYMENT_ROOT).getRoot().getChild(SINGLETON_DEPLOYMENT_DESCRIPTOR);
if (file.exists()) {
try {
unit.putAttachment(SingletonDeploymentDependencyProcessor.CONFIGURATION_KEY, this.parse(unit, file.getPhysicalFile()));
} catch (IOException e) {
throw new DeploymentUnitProcessingException(e);
}
}
}
}
@Override
public void undeploy(DeploymentUnit unit) {
unit.removeAttachment(SingletonDeploymentDependencyProcessor.CONFIGURATION_KEY);
}
private SingletonDeploymentConfiguration parse(DeploymentUnit unit, File file) throws DeploymentUnitProcessingException {
try (BufferedReader reader = Files.newBufferedReader(file.toPath(), StandardCharsets.UTF_8)) {
XMLStreamReader xmlReader = XML_INPUT_FACTORY.createXMLStreamReader(reader);
try {
MutableSingletonDeploymentConfiguration config = new MutableSingletonDeploymentConfiguration(unit);
this.mapper.parseDocument(config, xmlReader);
return config;
} finally {
xmlReader.close();
}
} catch (XMLStreamException e) {
throw ServerLogger.ROOT_LOGGER.errorLoadingDeploymentStructureFile(file.getPath(), e);
} catch (FileNotFoundException e) {
throw ServerLogger.ROOT_LOGGER.deploymentStructureFileNotFound(file);
} catch (IOException e) {
throw ServerLogger.ROOT_LOGGER.deploymentStructureFileNotFound(file);
}
}
}
| 4,347
| 43.824742
| 139
|
java
|
null |
wildfly-main/clustering/singleton/extension/src/main/java/org/wildfly/extension/clustering/singleton/deployment/SingletonDeploymentDependencyProcessor.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.singleton.deployment;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.as.server.deployment.AttachmentKey;
import org.jboss.as.server.deployment.Attachments;
import org.jboss.as.server.deployment.DeploymentPhaseContext;
import org.jboss.as.server.deployment.DeploymentUnit;
import org.jboss.as.server.deployment.DeploymentUnitProcessingException;
import org.jboss.as.server.deployment.DeploymentUnitProcessor;
import org.wildfly.extension.clustering.singleton.SingletonServiceNameFactory;
/**
* DUP that adds a dependency on a configured deployment policy service to the next phase.
* @author Paul Ferraro
*/
public class SingletonDeploymentDependencyProcessor implements DeploymentUnitProcessor {
public static final AttachmentKey<SingletonDeploymentConfiguration> CONFIGURATION_KEY = AttachmentKey.create(SingletonDeploymentConfiguration.class);
@Override
public void deploy(DeploymentPhaseContext context) throws DeploymentUnitProcessingException {
DeploymentUnit unit = context.getDeploymentUnit();
if (unit.getParent() == null) {
SingletonDeploymentConfiguration config = unit.getAttachment(CONFIGURATION_KEY);
if (config != null) {
CapabilityServiceSupport support = unit.getAttachment(Attachments.CAPABILITY_SERVICE_SUPPORT);
context.addDependency(SingletonServiceNameFactory.SINGLETON_POLICY.getServiceName(support, config.getPolicy()), SingletonDeploymentProcessor.POLICY_KEY);
}
}
}
}
| 2,611
| 47.37037
| 169
|
java
|
null |
wildfly-main/clustering/singleton/extension/src/main/java/org/wildfly/extension/clustering/singleton/deployment/SingletonDeploymentUnitPhaseBuilder.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.singleton.deployment;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.as.server.deployment.DeploymentUnitPhaseBuilder;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceController;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.wildfly.clustering.singleton.SingletonPolicy;
/**
* Builds a singleton service for the next phase in the deployment chain, if configured.
* @author Paul Ferraro
*/
@SuppressWarnings({ "removal", "deprecation" })
public class SingletonDeploymentUnitPhaseBuilder implements DeploymentUnitPhaseBuilder {
private static final String EJB_REMOTE_CAPABILITY = "org.wildfly.ejb.remote";
private final CapabilityServiceSupport support;
private final SingletonPolicy policy;
public SingletonDeploymentUnitPhaseBuilder(CapabilityServiceSupport support, SingletonPolicy policy) {
this.support = support;
this.policy = policy;
}
@Override
public <T> ServiceBuilder<T> build(ServiceTarget target, ServiceName name, Service<T> service) {
ServiceBuilder<T> builder = this.policy.createSingletonServiceBuilder(name, service).build(target).setInitialMode(ServiceController.Mode.ACTIVE);
if (this.support.hasCapability(EJB_REMOTE_CAPABILITY)) {
builder.requires(this.support.getCapabilityServiceName(EJB_REMOTE_CAPABILITY));
}
return builder;
}
}
| 2,577
| 42.694915
| 153
|
java
|
null |
wildfly-main/clustering/singleton/service/src/main/java/org/wildfly/clustering/singleton/service/SingletonCacheRequirement.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.service;
import org.jboss.as.clustering.controller.BinaryRequirementServiceNameFactory;
import org.jboss.as.clustering.controller.BinaryServiceNameFactory;
import org.jboss.as.clustering.controller.DefaultableBinaryServiceNameFactoryProvider;
import org.jboss.as.clustering.controller.UnaryServiceNameFactory;
import org.wildfly.clustering.service.BinaryRequirement;
/**
* @author Paul Ferraro
*/
public enum SingletonCacheRequirement implements DefaultableBinaryServiceNameFactoryProvider {
@Deprecated(forRemoval = true) SINGLETON_SERVICE_BUILDER_FACTORY(org.wildfly.clustering.singleton.SingletonCacheRequirement.SINGLETON_SERVICE_BUILDER_FACTORY, SingletonDefaultCacheRequirement.SINGLETON_SERVICE_BUILDER_FACTORY),
SINGLETON_SERVICE_CONFIGURATOR_FACTORY(org.wildfly.clustering.singleton.SingletonCacheRequirement.SINGLETON_SERVICE_CONFIGURATOR_FACTORY, SingletonDefaultCacheRequirement.SINGLETON_SERVICE_CONFIGURATOR_FACTORY),
;
private final BinaryServiceNameFactory factory;
private final SingletonDefaultCacheRequirement defaultRequirement;
SingletonCacheRequirement(BinaryRequirement requirement, SingletonDefaultCacheRequirement defaultRequirement) {
this.factory = new BinaryRequirementServiceNameFactory(requirement);
this.defaultRequirement = defaultRequirement;
}
@Override
public BinaryServiceNameFactory getServiceNameFactory() {
return this.factory;
}
@Override
public UnaryServiceNameFactory getDefaultServiceNameFactory() {
return this.defaultRequirement;
}
}
| 2,634
| 46.909091
| 231
|
java
|
null |
wildfly-main/clustering/singleton/service/src/main/java/org/wildfly/clustering/singleton/service/SingletonDefaultCacheRequirement.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.service;
import org.jboss.as.clustering.controller.UnaryRequirementServiceNameFactory;
import org.jboss.as.clustering.controller.UnaryServiceNameFactory;
import org.jboss.as.clustering.controller.UnaryServiceNameFactoryProvider;
import org.wildfly.clustering.service.UnaryRequirement;
/**
* @author Paul Ferraro
*/
public enum SingletonDefaultCacheRequirement implements UnaryServiceNameFactoryProvider {
@Deprecated(forRemoval = true) SINGLETON_SERVICE_BUILDER_FACTORY(org.wildfly.clustering.singleton.SingletonDefaultCacheRequirement.SINGLETON_SERVICE_BUILDER_FACTORY),
SINGLETON_SERVICE_CONFIGURATOR_FACTORY(org.wildfly.clustering.singleton.SingletonDefaultCacheRequirement.SINGLETON_SERVICE_CONFIGURATOR_FACTORY),
;
private final UnaryServiceNameFactory factory;
SingletonDefaultCacheRequirement(UnaryRequirement requirement) {
this.factory = new UnaryRequirementServiceNameFactory(requirement);
}
@Override
public UnaryServiceNameFactory getServiceNameFactory() {
return this.factory;
}
}
| 2,116
| 44.042553
| 170
|
java
|
null |
wildfly-main/clustering/singleton/api/src/test/java/org/wildfly/clustering/server/singleton/election/PreferredSingletonElectionPolicyTestCase.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2008, Red Hat Middleware LLC, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.server.singleton.election;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.mockito.ArgumentMatchers.same;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
import org.wildfly.clustering.singleton.election.Preference;
import org.wildfly.clustering.singleton.election.PreferredSingletonElectionPolicy;
/**
* @author Paul Ferraro
*/
public class PreferredSingletonElectionPolicyTestCase {
@Test
public void elect() {
SingletonElectionPolicy policy = mock(SingletonElectionPolicy.class);
Preference preference1 = mock(Preference.class);
Preference preference2 = mock(Preference.class);
Node node1 = mock(Node.class);
Node node2 = mock(Node.class);
Node node3 = mock(Node.class);
Node node4 = mock(Node.class);
when(preference1.preferred(same(node1))).thenReturn(true);
when(preference1.preferred(same(node2))).thenReturn(false);
when(preference1.preferred(same(node3))).thenReturn(false);
when(preference1.preferred(same(node4))).thenReturn(false);
when(preference2.preferred(same(node1))).thenReturn(false);
when(preference2.preferred(same(node2))).thenReturn(true);
when(preference2.preferred(same(node3))).thenReturn(false);
when(preference2.preferred(same(node4))).thenReturn(false);
assertSame(node1, new PreferredSingletonElectionPolicy(policy, preference1, preference2).elect(Arrays.asList(node1, node2, node3, node4)));
assertSame(node1, new PreferredSingletonElectionPolicy(policy, preference1, preference2).elect(Arrays.asList(node4, node3, node2, node1)));
assertSame(node2, new PreferredSingletonElectionPolicy(policy, preference1, preference2).elect(Arrays.asList(node2, node3, node4)));
assertSame(node2, new PreferredSingletonElectionPolicy(policy, preference1, preference2).elect(Arrays.asList(node4, node3, node2)));
List<Node> nodes = Arrays.asList(node3, node4);
when(policy.elect(nodes)).thenReturn(node3);
assertSame(node3, new PreferredSingletonElectionPolicy(policy, preference1, preference2).elect(nodes));
when(policy.elect(nodes)).thenReturn(node4);
assertSame(node4, new PreferredSingletonElectionPolicy(policy, preference1, preference2).elect(nodes));
when(policy.elect(nodes)).thenReturn(null);
assertNull(new PreferredSingletonElectionPolicy(policy, preference1, preference2).elect(nodes));
}
}
| 3,784
| 44.60241
| 147
|
java
|
null |
wildfly-main/clustering/singleton/api/src/test/java/org/wildfly/clustering/server/singleton/election/SocketAddressPreferenceTestCase.java
|
package org.wildfly.clustering.server.singleton.election;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import org.junit.Test;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.singleton.election.Preference;
import org.wildfly.clustering.singleton.election.SocketAddressPreference;
public class SocketAddressPreferenceTestCase {
@Test
public void test() throws UnknownHostException {
InetSocketAddress preferredAddress = new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 1);
InetSocketAddress otherAddress1 = new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 2);
InetSocketAddress otherAddress2 = new InetSocketAddress(InetAddress.getByName("127.0.0.2"), 1);
Preference preference = new SocketAddressPreference(preferredAddress);
Node preferredNode = mock(Node.class);
Node otherNode1 = mock(Node.class);
Node otherNode2 = mock(Node.class);
when(preferredNode.getSocketAddress()).thenReturn(preferredAddress);
when(otherNode1.getSocketAddress()).thenReturn(otherAddress1);
when(otherNode2.getSocketAddress()).thenReturn(otherAddress2);
assertTrue(preference.preferred(preferredNode));
assertFalse(preference.preferred(otherNode1));
assertFalse(preference.preferred(otherNode2));
}
}
| 1,568
| 39.230769
| 106
|
java
|
null |
wildfly-main/clustering/singleton/api/src/test/java/org/wildfly/clustering/server/singleton/election/NamePreferenceTestCase.java
|
package org.wildfly.clustering.server.singleton.election;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.junit.Test;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.singleton.election.NamePreference;
import org.wildfly.clustering.singleton.election.Preference;
public class NamePreferenceTestCase {
@Test
public void test() {
Preference preference = new NamePreference("node1");
Node node1 = mock(Node.class);
Node node2 = mock(Node.class);
when(node1.getName()).thenReturn("node1");
when(node2.getName()).thenReturn("node2");
assertTrue(preference.preferred(node1));
assertFalse(preference.preferred(node2));
}
}
| 843
| 29.142857
| 64
|
java
|
null |
wildfly-main/clustering/singleton/api/src/test/java/org/wildfly/clustering/server/singleton/election/SimpleSingletonElectionPolicyTestCase.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2008, Red Hat Middleware LLC, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.server.singleton.election;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.mockito.Mockito.mock;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.singleton.election.SimpleSingletonElectionPolicy;
/**
* @author Paul Ferraro
*/
public class SimpleSingletonElectionPolicyTestCase {
@Test
public void elect() {
Node node1 = mock(Node.class);
Node node2 = mock(Node.class);
Node node3 = mock(Node.class);
List<Node> nodes = Arrays.asList(node1, node2, node3);
assertSame(node1, new SimpleSingletonElectionPolicy().elect(nodes));
assertSame(node1, new SimpleSingletonElectionPolicy(0).elect(nodes));
assertSame(node2, new SimpleSingletonElectionPolicy(1).elect(nodes));
assertSame(node3, new SimpleSingletonElectionPolicy(2).elect(nodes));
assertSame(node1, new SimpleSingletonElectionPolicy(3).elect(nodes));
assertNull(new SimpleSingletonElectionPolicy().elect(Collections.<Node>emptyList()));
}
}
| 2,237
| 38.964286
| 93
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/SingletonElectionListener.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import java.util.List;
import org.wildfly.clustering.group.Node;
/**
* Listener for singleton election results.
* @author Paul Ferraro
*/
public interface SingletonElectionListener {
/**
* Triggered when a singleton election completes, electing the specified member from the specified list of candidates.
* @param candidateMembers the list of candidate members
* @param electedMember the elected primary provider of a singleton service
*/
void elected(List<Node> candidateMembers, Node electedMember);
}
| 1,604
| 38.146341
| 122
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/Singleton.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2011, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import java.util.Set;
import org.wildfly.clustering.group.Node;
/**
* @author Paul Ferraro
*/
public interface Singleton {
/**
* Indicates whether this node is the primary provider of the singleton.
* @return true, if this node is the primary node, false if it is a backup node.
*/
boolean isPrimary();
/**
* Returns the current primary provider of the singleton.
* @return a cluster member
*/
Node getPrimaryProvider();
/**
* Returns the providers on which the given singleton is available.
* @return a set of cluster members
*/
Set<Node> getProviders();
}
| 1,700
| 32.352941
| 84
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/SingletonServiceBuilderFactory.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory;
/**
* Factory for creating a singleton service builder.
* @author Paul Ferraro
* @deprecated Replaced by {@link SingletonServiceConfiguratorFactory}
*/
@Deprecated(forRemoval = true)
public interface SingletonServiceBuilderFactory extends SingletonPolicy, SingletonServiceConfiguratorFactory {
@Override
<T> SingletonServiceBuilder<T> createSingletonServiceBuilder(ServiceName name, Service<T> service);
@Override
<T> SingletonServiceBuilder<T> createSingletonServiceBuilder(ServiceName name, Service<T> primaryService, Service<T> backupService);
}
| 1,803
| 41.952381
| 136
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/SingletonService.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import org.jboss.msc.service.Service;
/**
* Implemented by the instrumented singleton service.
* @author Paul Ferraro
* @deprecated Replaced by {@link org.wildfly.clustering.singleton.service.SingletonService}.
*/
@Deprecated(forRemoval = true)
public interface SingletonService<T> extends org.wildfly.clustering.singleton.service.SingletonService, Service<T> {
}
| 1,437
| 38.944444
| 116
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/SingletonCacheRequirement.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import org.wildfly.clustering.service.DefaultableBinaryRequirement;
import org.wildfly.clustering.service.UnaryRequirement;
/**
* @author Paul Ferraro
*/
public enum SingletonCacheRequirement implements DefaultableBinaryRequirement {
/**
* @deprecated Use {@link SingletonCacheRequirement#SINGLETON_SERVICE_CONFIGURATOR_FACTORY} instead.
*/
@Deprecated(forRemoval = true) SINGLETON_SERVICE_BUILDER_FACTORY("org.wildfly.clustering.cache.singleton-service-builder-factory", SingletonDefaultCacheRequirement.SINGLETON_SERVICE_BUILDER_FACTORY),
SINGLETON_SERVICE_CONFIGURATOR_FACTORY("org.wildfly.clustering.cache.singleton-service-configurator-factory", SingletonDefaultCacheRequirement.SINGLETON_SERVICE_CONFIGURATOR_FACTORY),
;
private final String name;
private final UnaryRequirement defaultRequirement;
SingletonCacheRequirement(String name, UnaryRequirement defaultRequirement) {
this.name = name;
this.defaultRequirement = defaultRequirement;
}
@Override
public String getName() {
return this.name;
}
@Override
public UnaryRequirement getDefaultRequirement() {
return this.defaultRequirement;
}
}
| 2,273
| 38.894737
| 203
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/SingletonElectionPolicy.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2011, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import java.util.List;
import org.wildfly.clustering.group.Node;
/**
* Used by a singleton service to elect the primary node from among the list of nodes that can provide the given service.
* @author Paul Ferraro
*/
public interface SingletonElectionPolicy {
/**
* Elect a single node from the specified list of candidate nodes.
* @param nodes a list of candidate nodes.
* @return the elected node
*/
Node elect(List<Node> nodes);
}
| 1,533
| 36.414634
| 121
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/SingletonRequirement.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import org.wildfly.clustering.service.DefaultableUnaryRequirement;
import org.wildfly.clustering.service.Requirement;
/**
* @author Paul Ferraro
*/
public enum SingletonRequirement implements DefaultableUnaryRequirement {
/**
* @deprecated Use {@link SingletonRequirement#POLICY} instead.
*/
@Deprecated(forRemoval = true) SINGLETON_POLICY("org.wildfly.clustering.singleton.policy", SingletonDefaultRequirement.SINGLETON_POLICY),
POLICY("org.wildfly.clustering.singleton-policy", SingletonDefaultRequirement.POLICY),
;
private final String name;
private final Requirement defaultRequirement;
SingletonRequirement(String name, Requirement defaultRequirement) {
this.name = name;
this.defaultRequirement = defaultRequirement;
}
@Override
public String getName() {
return this.name;
}
@Override
public Requirement getDefaultRequirement() {
return this.defaultRequirement;
}
}
| 2,044
| 35.517857
| 141
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/SingletonDefaultCacheRequirement.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import org.wildfly.clustering.service.UnaryRequirement;
import org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory;
/**
* @author Paul Ferraro
*/
public enum SingletonDefaultCacheRequirement implements UnaryRequirement {
/**
* @deprecated Use {@link SingletonDefaultCacheRequirement#SINGLETON_SERVICE_CONFIGURATOR_FACTORY} instead.
*/
@Deprecated(forRemoval = true) SINGLETON_SERVICE_BUILDER_FACTORY("org.wildfly.clustering.cache.default-singleton-service-builder-factory", SingletonServiceBuilderFactory.class),
SINGLETON_SERVICE_CONFIGURATOR_FACTORY("org.wildfly.clustering.cache.default-singleton-service-configurator-factory", SingletonServiceConfiguratorFactory.class),
;
private final String name;
private final Class<?> type;
SingletonDefaultCacheRequirement(String name, Class<?> type) {
this.name = name;
this.type = type;
}
@Override
public String getName() {
return this.name;
}
@Override
public Class<?> getType() {
return this.type;
}
}
| 2,147
| 36.684211
| 181
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/SingletonDefaultRequirement.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import org.wildfly.clustering.service.Requirement;
/**
* Enumerates capability requirements for default singleton resources
* @author Paul Ferraro
*/
public enum SingletonDefaultRequirement implements Requirement {
/**
* @deprecated Use {@link SingletonDefaultRequirement#POLICY} instead.
*/
@Deprecated(forRemoval = true) SINGLETON_POLICY("org.wildfly.clustering.singleton.default-policy", org.wildfly.clustering.singleton.SingletonPolicy.class),
POLICY("org.wildfly.clustering.default-singleton-policy", org.wildfly.clustering.singleton.service.SingletonPolicy.class),
;
private final String name;
private final Class<?> type;
SingletonDefaultRequirement(String name, Class<?> type) {
this.name = name;
this.type = type;
}
@Override
public String getName() {
return this.name;
}
@Override
public Class<?> getType() {
return this.type;
}
}
| 2,013
| 34.964286
| 159
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/SingletonServiceBuilder.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import org.wildfly.clustering.service.Builder;
import org.wildfly.clustering.singleton.service.SingletonServiceConfigurator;
/**
* Builds a singleton service.
* @author Paul Ferraro
* @param <T> the singleton service value type
* @deprecated Replaced by {@link SingletonServiceConfigurator}.
*/
@Deprecated(forRemoval = true)
public interface SingletonServiceBuilder<T> extends Builder<T> {
/**
* Defines the minimum number of members required before a singleton election will take place.
* @param quorum the quorum required for electing a primary singleton provider
* @return a reference to this builder
*/
SingletonServiceBuilder<T> requireQuorum(int quorum);
/**
* Defines the policy for electing a primary singleton provider.
* @param policy an election policy
* @return a reference to this builder
*/
SingletonServiceBuilder<T> electionPolicy(SingletonElectionPolicy policy);
/**
* Defines a listener to trigger following the election of a primary singleton provider.
* @param listener an election listener
* @return a reference to this builder
*/
SingletonServiceBuilder<T> electionListener(SingletonElectionListener listener);
}
| 2,295
| 39.280702
| 98
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/SingletonPolicy.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.service.Builder;
/**
* Defines a singleton policy.
* @author Paul Ferraro
* @deprecated Replaced by {@link org.wildfly.clustering.singleton.service.SingletonPolicy}.
*/
@Deprecated(forRemoval = true)
public interface SingletonPolicy extends org.wildfly.clustering.singleton.service.SingletonPolicy {
/**
* Creates a singleton service builder.
* @param name the name of the service
* @param service the service to run when elected as the primary node
* @return a builder
* @deprecated Use {@link #createSingletonServiceConfigurator(ServiceName)} instead.
*/
@Deprecated
<T> Builder<T> createSingletonServiceBuilder(ServiceName name, Service<T> service);
/**
* Creates a singleton service builder.
* @param name the name of the service
* @param primaryService the service to run when elected as the primary node
* @param backupService the service to run when not elected as the primary node
* @return a builder
* @deprecated Use {@link #createSingletonServiceConfigurator(ServiceName)} instead.
*/
@Deprecated
<T> Builder<T> createSingletonServiceBuilder(ServiceName name, Service<T> primaryService, Service<T> backupService);
}
| 2,400
| 40.396552
| 120
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/service/ImmutableSingletonServiceConfigurator.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.service;
import org.jboss.msc.service.ServiceTarget;
import org.wildfly.clustering.service.ServiceConfigurator;
/**
* An immutable {@link ServiceConfigurator} used to build a singleton service.
* @author Paul Ferraro
*/
public interface ImmutableSingletonServiceConfigurator extends ServiceConfigurator {
@Override
SingletonServiceBuilder<?> build(ServiceTarget target);
}
| 1,452
| 38.27027
| 84
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/service/SingletonService.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.service;
import org.jboss.msc.Service;
import org.wildfly.clustering.singleton.Singleton;
/**
* Implemented by the instrumented singleton service.
* @author Paul Ferraro
*/
public interface SingletonService extends Singleton, Service {
}
| 1,309
| 36.428571
| 70
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/service/SingletonServiceConfiguratorFactory.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.service;
import org.jboss.msc.service.ServiceName;
/**
* Extension of {@link SingletonPolicy} for customizing singleton service behavior.
* @author Paul Ferraro
*/
public interface SingletonServiceConfiguratorFactory extends SingletonPolicy {
@Override
SingletonServiceConfigurator createSingletonServiceConfigurator(ServiceName name);
}
| 1,417
| 38.388889
| 86
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/service/SingletonServiceConfigurator.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.service;
import org.wildfly.clustering.singleton.SingletonElectionListener;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
/**
* Extension of {@link ImmutableSingletonServiceConfigurator} for customizing singleton service behavior.
* @author Paul Ferraro
*/
public interface SingletonServiceConfigurator extends ImmutableSingletonServiceConfigurator {
/**
* Defines the minimum number of members required before a singleton election will take place.
* @param quorum the quorum required for electing a primary singleton provider
* @return a reference to this configurator
*/
SingletonServiceConfigurator requireQuorum(int quorum);
/**
* Defines the policy for electing a primary singleton provider.
* @param policy an election policy
* @return a reference to this configurator
*/
SingletonServiceConfigurator electionPolicy(SingletonElectionPolicy policy);
/**
* Defines a listener to trigger following the election of a primary singleton provider.
* @param listener an election listener
* @return a reference to this configurator
*/
SingletonServiceConfigurator electionListener(SingletonElectionListener listener);
}
| 2,292
| 41.462963
| 105
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/service/SingletonServiceBuilder.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.service;
import org.jboss.msc.service.ServiceBuilder;
/**
* Extends {@link ServiceBuilder} to facilitate building singleton services.
* @author Paul Ferraro
*/
public interface SingletonServiceBuilder<T> extends ServiceBuilder<T> {
}
| 1,305
| 37.411765
| 76
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/service/SingletonPolicy.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.service;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.service.ServiceConfigurator;
/**
* Defines a policy for creating singleton services.
* @author Paul Ferraro
*/
public interface SingletonPolicy {
ServiceConfigurator createSingletonServiceConfigurator(ServiceName name);
}
| 1,378
| 37.305556
| 77
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/election/NamePreference.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.election;
import org.wildfly.clustering.group.Node;
public class NamePreference implements Preference {
private final String name;
public NamePreference(String name) {
this.name = name;
}
@Override
public boolean preferred(Node node) {
return node.getName().equals(this.name);
}
@Override
public String toString() {
return this.name;
}
}
| 1,467
| 33.139535
| 70
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/election/SimpleSingletonElectionPolicy.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.election;
import java.util.List;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
/**
* A simple concrete policy service that decides which node in the cluster should be the primary node to run certain HASingleton
* service based on attribute "Position". The value will be divided by partition size and only remainder will be used.
*
* Let's say partition size is n: 0 means the first oldest node. 1 means the 2nd oldest node. ... n-1 means the nth oldest node.
*
* -1 means the youngest node. -2 means the 2nd youngest node. ... -n means the nth youngest node.
*
* E.g. the following attribute says the singleton will be running on the 3rd oldest node of the current partition: <attribute
* name="Position">2</attribute>
*
* If no election policy is defined, the oldest node in the cluster runs the singleton. This behavior can be achieved with this
* policy when "position" is set to 0.
*
* @author <a href="mailto:Alex.Fu@novell.com">Alex Fu</a>
* @author <a href="mailto:galder.zamarreno@jboss.com">Galder Zamarreno</a>
* @author Paul Ferraro
*/
public class SimpleSingletonElectionPolicy implements SingletonElectionPolicy {
private final int position;
public SimpleSingletonElectionPolicy() {
this(0);
}
public SimpleSingletonElectionPolicy(int position) {
this.position = position;
}
@Override
public Node elect(List<Node> candidates) {
int size = candidates.size();
return (size > 0) ? candidates.get(((this.position % size) + size) % size) : null;
}
}
| 2,671
| 40.107692
| 128
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/election/SocketAddressPreference.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.election;
import java.net.InetSocketAddress;
import org.wildfly.clustering.group.Node;
public class SocketAddressPreference implements Preference {
private final InetSocketAddress address;
public SocketAddressPreference(InetSocketAddress address) {
this.address = address;
}
@Override
public boolean preferred(Node node) {
return node.getSocketAddress().getAddress().getHostAddress().equals(this.address.getAddress().getHostAddress()) && (node.getSocketAddress().getPort() == this.address.getPort());
}
@Override
public String toString() {
return this.address.toString();
}
}
| 1,706
| 36.933333
| 185
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/election/Preference.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.election;
import org.wildfly.clustering.group.Node;
public interface Preference {
boolean preferred(Node node);
}
| 1,184
| 39.862069
| 70
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/election/PreferredSingletonElectionPolicy.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.election;
import java.util.Arrays;
import java.util.List;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
/**
* An election policy that always elects a preferred node, and defers to a default policy
* if the preferred node is not a candidate. The means of specifying the preferred node is
* the responsibility of the extending class.
* @author Paul Ferraro
*/
public class PreferredSingletonElectionPolicy implements SingletonElectionPolicy {
private final List<Preference> preferences;
private final SingletonElectionPolicy policy;
public PreferredSingletonElectionPolicy(SingletonElectionPolicy policy, Preference... preferences) {
this(policy, Arrays.asList(preferences));
}
public PreferredSingletonElectionPolicy(SingletonElectionPolicy policy, List<Preference> preferences) {
this.policy = policy;
this.preferences = preferences;
}
@Override
public Node elect(List<Node> candidates) {
for (Preference preference: this.preferences) {
for (Node candidate: candidates) {
if (preference.preferred(candidate)) {
return candidate;
}
}
}
return this.policy.elect(candidates);
}
}
| 2,374
| 37.934426
| 107
|
java
|
null |
wildfly-main/clustering/singleton/api/src/main/java/org/wildfly/clustering/singleton/election/RandomSingletonElectionPolicy.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.election;
import java.util.List;
import java.util.Random;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
/**
* {@link SingletonElectionPolicy} that elects a random member.
* @author Paul Ferraro
*/
public class RandomSingletonElectionPolicy implements SingletonElectionPolicy {
private final Random random = new Random(System.currentTimeMillis());
/**
* {@inheritDoc}
*/
@Override
public Node elect(List<Node> nodes) {
int size = nodes.size();
return (size > 0) ? nodes.get(this.random.nextInt(size)) : null;
}
}
| 1,692
| 34.270833
| 79
|
java
|
null |
wildfly-main/clustering/singleton/server/src/test/java/org/wildfly/clustering/singleton/server/ExceptionTestCase.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2020, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.io.IOException;
import org.jboss.msc.service.ServiceNotFoundException;
import org.jboss.msc.service.StartException;
import org.junit.Assert;
import org.junit.Test;
import org.wildfly.clustering.marshalling.Tester;
import org.wildfly.clustering.marshalling.protostream.ProtoStreamTesterFactory;
/**
* Unit test for marshalling of singleton service exceptions.
* @author Paul Ferraro
*/
public class ExceptionTestCase {
@Test
public void test() throws IOException {
Tester<Throwable> tester = ProtoStreamTesterFactory.INSTANCE.createTester();
tester.test(new StartException(), ExceptionTestCase::assertEquals);
tester.test(new StartException("message"), ExceptionTestCase::assertEquals);
tester.test(new StartException(new Exception()), ExceptionTestCase::assertEquals);
tester.test(new StartException("message", new Exception()), ExceptionTestCase::assertEquals);
tester.test(new ServiceNotFoundException(), ExceptionTestCase::assertEquals);
tester.test(new ServiceNotFoundException("message"), ExceptionTestCase::assertEquals);
tester.test(new ServiceNotFoundException(new Exception()), ExceptionTestCase::assertEquals);
tester.test(new ServiceNotFoundException("message", new Exception()), ExceptionTestCase::assertEquals);
}
private static void assertEquals(Throwable exception1, Throwable exception2) {
if ((exception1 != null) && (exception2 != null)) {
Assert.assertSame(exception1.getClass(), exception2.getClass());
Assert.assertEquals(exception1.getMessage(), exception2.getMessage());
assertEquals(exception1.getCause(), exception2.getCause());
} else {
Assert.assertSame(exception1, exception2);
}
}
}
| 2,870
| 43.859375
| 111
|
java
|
null |
wildfly-main/clustering/singleton/server/src/test/java/org/wildfly/clustering/singleton/server/ServiceNameFormatterTestCase.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2017, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.io.IOException;
import org.jboss.msc.service.ServiceName;
import org.junit.Test;
import org.wildfly.clustering.infinispan.persistence.DynamicKeyFormatMapper;
import org.wildfly.clustering.infinispan.persistence.KeyMapperTester;
import org.wildfly.clustering.marshalling.ExternalizerTester;
import org.wildfly.clustering.marshalling.jboss.JBossMarshallingTesterFactory;
import org.wildfly.clustering.marshalling.protostream.ProtoStreamTesterFactory;
import org.wildfly.clustering.marshalling.spi.FormatterTester;
import org.wildfly.clustering.singleton.server.ServiceNameFormatter.ServiceNameExternalizer;
/**
* Unit test for {@link ServiceNameFormatter}.
* @author Paul Ferraro
*/
public class ServiceNameFormatterTestCase {
private final ServiceName name = ServiceName.JBOSS.append("foo", "bar");
@Test
public void test() throws IOException {
new ExternalizerTester<>(new ServiceNameExternalizer()).test(this.name);
new FormatterTester<>(new ServiceNameFormatter()).test(this.name);
new KeyMapperTester(new DynamicKeyFormatMapper(Thread.currentThread().getContextClassLoader())).test(this.name);
JBossMarshallingTesterFactory.INSTANCE.createTester().test(this.name);
ProtoStreamTesterFactory.INSTANCE.createTester().test(this.name);
}
}
| 2,387
| 43.222222
| 120
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/AbstractDistributedSingletonService.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CompletionException;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Function;
import java.util.function.Supplier;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceNotFoundException;
import org.jboss.msc.service.ServiceTarget;
import org.jboss.msc.service.StartContext;
import org.jboss.msc.service.StartException;
import org.jboss.msc.service.StopContext;
import org.wildfly.clustering.dispatcher.CommandDispatcher;
import org.wildfly.clustering.dispatcher.CommandDispatcherException;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.provider.ServiceProviderRegistration;
import org.wildfly.clustering.provider.ServiceProviderRegistration.Listener;
import org.wildfly.clustering.provider.ServiceProviderRegistry;
import org.wildfly.clustering.server.dispatcher.CommandDispatcherFactory;
import org.wildfly.clustering.singleton.SingletonElectionListener;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
import org.wildfly.clustering.singleton.service.SingletonService;
import org.wildfly.security.manager.WildFlySecurityManager;
/**
* Logic common to current and legacy {@link SingletonService} implementations.
* @author Paul Ferraro
*/
public abstract class AbstractDistributedSingletonService<C extends SingletonContext> implements SingletonService, SingletonContext, Listener, Supplier<C> {
private final ServiceName name;
private final Supplier<ServiceProviderRegistry<ServiceName>> registry;
private final Supplier<CommandDispatcherFactory> dispatcherFactory;
private final SingletonElectionPolicy electionPolicy;
private final SingletonElectionListener electionListener;
private final int quorum;
private final Function<ServiceTarget, Lifecycle> primaryLifecycleFactory;
private final AtomicBoolean primary = new AtomicBoolean(false);
private volatile Lifecycle primaryLifecycle;
private volatile CommandDispatcher<C> dispatcher;
private volatile ServiceProviderRegistration<ServiceName> registration;
public AbstractDistributedSingletonService(DistributedSingletonServiceContext context, Function<ServiceTarget, Lifecycle> primaryLifecycleFactory) {
this.name = context.getServiceName();
this.registry = context.getServiceProviderRegistry();
this.dispatcherFactory = context.getCommandDispatcherFactory();
this.electionPolicy = context.getElectionPolicy();
this.electionListener = context.getElectionListener();
this.quorum = context.getQuorum();
this.primaryLifecycleFactory = primaryLifecycleFactory;
}
@Override
public void start(StartContext context) throws StartException {
ServiceTarget target = context.getChildTarget();
this.primaryLifecycle = this.primaryLifecycleFactory.apply(target);
this.dispatcher = this.dispatcherFactory.get().createCommandDispatcher(this.name.getCanonicalName(), this.get(), WildFlySecurityManager.getClassLoaderPrivileged(this.getClass()));
this.registration = this.registry.get().register(this.name, this);
}
@Override
public void stop(StopContext context) {
this.registration.close();
this.dispatcher.close();
}
@Override
public synchronized void providersChanged(Set<Node> nodes) {
Group group = this.registry.get().getGroup();
List<Node> candidates = new ArrayList<>(group.getMembership().getMembers());
candidates.retainAll(nodes);
// Only run election on a single node
if (candidates.isEmpty() || candidates.get(0).equals(group.getLocalMember())) {
// First validate that quorum was met
int size = candidates.size();
boolean quorumMet = size >= this.quorum;
if ((this.quorum > 1) && (size == this.quorum)) {
// Log fragility of singleton availability
SingletonLogger.ROOT_LOGGER.quorumJustReached(this.name.getCanonicalName(), this.quorum);
}
Node elected = quorumMet ? this.electionPolicy.elect(candidates) : null;
try {
if (elected != null) {
// Stop service on every node except elected node
for (Map.Entry<Node, CompletionStage<Void>> entry : this.dispatcher.executeOnGroup(new StopCommand(), elected).entrySet()) {
try {
entry.getValue().toCompletableFuture().join();
} catch (CancellationException e) {
SingletonLogger.ROOT_LOGGER.tracef("Singleton service %s is not installed on %s", this.name.getCanonicalName(), entry.getKey().getName());
} catch (CompletionException e) {
Throwable cause = e.getCause();
if ((cause instanceof IllegalStateException) && (cause.getCause() instanceof ServiceNotFoundException)) {
SingletonLogger.ROOT_LOGGER.debugf("Singleton service %s is no longer installed on %s", this.name.getCanonicalName(), entry.getKey().getName());
} else {
throw e;
}
}
}
// Start service on elected node
try {
this.dispatcher.executeOnMember(new StartCommand(), elected).toCompletableFuture().join();
} catch (CancellationException e) {
SingletonLogger.ROOT_LOGGER.debugf("Singleton service %s could not be started on the elected primary singleton provider (%s) because it left the cluster. A new primary provider election will take place.", this.name.getCanonicalName(), elected.getName());
} catch (CompletionException e) {
Throwable cause = e.getCause();
if ((cause instanceof IllegalStateException) && (cause.getCause() instanceof ServiceNotFoundException)) {
SingletonLogger.ROOT_LOGGER.debugf("Service % is no longer installed on the elected primary singleton provider (%s). A new primary provider election will take place.", this.name.getCanonicalName(), elected.getName());
} else {
throw e;
}
}
} else {
if (!quorumMet) {
SingletonLogger.ROOT_LOGGER.quorumNotReached(this.name.getCanonicalName(), this.quorum);
}
// Stop service on every node
for (Map.Entry<Node, CompletionStage<Void>> entry : this.dispatcher.executeOnGroup(new StopCommand()).entrySet()) {
try {
entry.getValue().toCompletableFuture().join();
} catch (CancellationException e) {
SingletonLogger.ROOT_LOGGER.tracef("Singleton service %s is not installed on %s", this.name.getCanonicalName(), entry.getKey().getName());
} catch (CompletionException e) {
Throwable cause = e.getCause();
if ((cause instanceof IllegalStateException) && (cause.getCause() instanceof ServiceNotFoundException)) {
SingletonLogger.ROOT_LOGGER.debugf("Singleton service %s is no longer installed on %s", this.name.getCanonicalName(), entry.getKey().getName());
} else {
throw e;
}
}
}
}
if (this.electionListener != null) {
for (CompletionStage<Void> stage : this.dispatcher.executeOnGroup(new SingletonElectionCommand(candidates, elected)).values()) {
try {
stage.toCompletableFuture().join();
} catch (CancellationException e) {
// Ignore
}
}
}
} catch (CommandDispatcherException e) {
throw new IllegalStateException(e);
}
}
}
@Override
public synchronized void start() {
// If we were not already the primary node
if (this.primary.compareAndSet(false, true)) {
this.primaryLifecycle.start();
}
}
@Override
public synchronized void stop() {
// If we were the previous the primary node
if (this.primary.compareAndSet(true, false)) {
this.primaryLifecycle.stop();
}
}
@Override
public void elected(List<Node> candidates, Node elected) {
try {
this.electionListener.elected(candidates, elected);
} catch (Throwable e) {
SingletonLogger.ROOT_LOGGER.warn(e.getLocalizedMessage(), e);
}
}
@Override
public boolean isPrimary() {
return this.primary.get();
}
@Override
public Node getPrimaryProvider() {
if (this.isPrimary()) return this.registry.get().getGroup().getLocalMember();
List<Node> primaryMembers = new LinkedList<>();
try {
for (Map.Entry<Node, CompletionStage<Boolean>> entry : this.dispatcher.executeOnGroup(new PrimaryProviderCommand()).entrySet()) {
try {
if (entry.getValue().toCompletableFuture().join()) {
primaryMembers.add(entry.getKey());
}
} catch (CancellationException e) {
// Ignore
}
}
if (primaryMembers.size() > 1) {
throw SingletonLogger.ROOT_LOGGER.multiplePrimaryProvidersDetected(this.name.getCanonicalName(), primaryMembers);
}
return !primaryMembers.isEmpty() ? primaryMembers.get(0) : null;
} catch (CommandDispatcherException e) {
throw new IllegalStateException(e);
}
}
@Override
public Set<Node> getProviders() {
return this.registration.getProviders();
}
int getQuorum() {
return this.quorum;
}
CommandDispatcher<C> getCommandDispatcher() {
return this.dispatcher;
}
ServiceProviderRegistration<ServiceName> getServiceProviderRegistration() {
return this.registration;
}
}
| 11,920
| 45.027027
| 279
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalSingletonServiceBuilder.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.function.Supplier;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.service.SimpleServiceNameProvider;
import org.wildfly.clustering.service.SupplierDependency;
import org.wildfly.clustering.singleton.SingletonElectionListener;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
import org.wildfly.clustering.singleton.SingletonService;
import org.wildfly.clustering.singleton.SingletonServiceBuilder;
import org.wildfly.clustering.singleton.service.SingletonServiceConfigurator;
/**
* Local {@link SingletonServiceConfigurator} implementation that uses JBoss MSC 1.3.x service installation.
* @author Paul Ferraro
*/
@Deprecated
public class LocalSingletonServiceBuilder<T> extends SimpleServiceNameProvider implements SingletonServiceBuilder<T>, LocalSingletonServiceContext {
private final Service<T> service;
private final SupplierDependency<Group> group;
private volatile SingletonElectionListener listener;
public LocalSingletonServiceBuilder(ServiceName name, Service<T> service, LocalSingletonServiceConfiguratorContext context) {
super(name);
this.service = service;
this.group = context.getGroupDependency();
this.listener = new DefaultSingletonElectionListener(name, this.group);
}
@Override
public SingletonServiceBuilder<T> requireQuorum(int quorum) {
// Quorum requirements are inconsequential to a local singleton
return this;
}
@Override
public SingletonServiceBuilder<T> electionPolicy(SingletonElectionPolicy policy) {
// Election policies are inconsequential to a local singleton
return this;
}
@Override
public SingletonServiceBuilder<T> electionListener(SingletonElectionListener listener) {
this.listener = listener;
return this;
}
@Override
public ServiceBuilder<T> build(ServiceTarget target) {
SingletonService<T> service = new LocalLegacySingletonService<>(this.service, this);
return this.group.register(target.addService(this.getServiceName(), service));
}
@Override
public Supplier<Group> getGroup() {
return this.group;
}
@Override
public SingletonElectionListener getElectionListener() {
return this.listener;
}
}
| 3,560
| 37.706522
| 148
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/StopCommand.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.wildfly.clustering.dispatcher.Command;
/**
* Command to stop a singleton service.
* @author Paul Ferraro
*/
public class StopCommand implements Command<Void, Lifecycle> {
private static final long serialVersionUID = 3194143912789013071L;
@Override
public Void execute(Lifecycle context) throws Exception {
context.stop();
return null;
}
}
| 1,461
| 35.55
| 70
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalSingletonServiceConfigurator.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.function.Supplier;
import org.jboss.msc.Service;
import org.jboss.msc.service.DelegatingServiceBuilder;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceController;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.service.SimpleServiceNameProvider;
import org.wildfly.clustering.service.SupplierDependency;
import org.wildfly.clustering.singleton.SingletonElectionListener;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
import org.wildfly.clustering.singleton.service.SingletonServiceBuilder;
import org.wildfly.clustering.singleton.service.SingletonServiceConfigurator;
/**
* Local {@link SingletonServiceConfigurator} implementation that uses JBoss MSC 1.4.x service installation.
* @author Paul Ferraro
*/
public class LocalSingletonServiceConfigurator extends SimpleServiceNameProvider implements SingletonServiceConfigurator, LocalSingletonServiceContext {
private final SupplierDependency<Group> group;
private volatile SingletonElectionListener listener;
public LocalSingletonServiceConfigurator(ServiceName name, LocalSingletonServiceConfiguratorContext context) {
super(name);
this.group = context.getGroupDependency();
this.listener = new DefaultSingletonElectionListener(name, this.group);
}
@Override
public SingletonServiceBuilder<?> build(ServiceTarget target) {
ServiceBuilder<?> builder = target.addService(this.getServiceName());
return new LocalSingletonServiceBuilder<>(this.group.register(builder), this);
}
@Override
public SingletonServiceConfigurator requireQuorum(int quorum) {
// Quorum requirements are inconsequential to a local singleton
return this;
}
@Override
public SingletonServiceConfigurator electionPolicy(SingletonElectionPolicy policy) {
// Election policies are inconsequential to a local singleton
return this;
}
@Override
public SingletonServiceConfigurator electionListener(SingletonElectionListener listener) {
this.listener = listener;
return this;
}
@Override
public Supplier<Group> getGroup() {
return this.group;
}
@Override
public SingletonElectionListener getElectionListener() {
return this.listener;
}
private static class LocalSingletonServiceBuilder<T> extends DelegatingServiceBuilder<T> implements SingletonServiceBuilder<T> {
private final LocalSingletonServiceContext context;
private Service service = Service.NULL;
LocalSingletonServiceBuilder(ServiceBuilder<T> builder, LocalSingletonServiceContext context) {
super(builder);
this.context = context;
}
@Override
public ServiceBuilder<T> setInstance(Service service) {
this.service = service;
return this;
}
@Override
public ServiceController<T> install() {
return this.getDelegate().setInstance(new LocalSingletonService(this.service, this.context)).install();
}
}
}
| 4,287
| 37.285714
| 152
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/SingletonElectionCommandMarshaller.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2020, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;
import org.infinispan.protostream.descriptors.WireType;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.marshalling.protostream.ProtoStreamMarshaller;
import org.wildfly.clustering.marshalling.protostream.ProtoStreamReader;
import org.wildfly.clustering.marshalling.protostream.ProtoStreamWriter;
/**
* @author Paul Ferraro
*/
public class SingletonElectionCommandMarshaller implements ProtoStreamMarshaller<SingletonElectionCommand> {
private static final int CANDIDATE_INDEX = 1;
private static final int ELECTED_INDEX = 2;
@Override
public SingletonElectionCommand readFrom(ProtoStreamReader reader) throws IOException {
List<Node> candidates = new LinkedList<>();
Integer elected = null;
while (!reader.isAtEnd()) {
int tag = reader.readTag();
switch (WireType.getTagFieldNumber(tag)) {
case CANDIDATE_INDEX:
candidates.add(reader.readAny(Node.class));
break;
case ELECTED_INDEX:
elected = reader.readUInt32();
break;
default:
reader.skipField(tag);
}
}
return new SingletonElectionCommand(candidates, elected);
}
@Override
public void writeTo(ProtoStreamWriter writer, SingletonElectionCommand command) throws IOException {
for (Node candidate : command.getCandidates()) {
writer.writeAny(CANDIDATE_INDEX, candidate);
}
Integer elected = command.getIndex();
if (elected != null) {
writer.writeUInt32(ELECTED_INDEX, elected);
}
}
@Override
public Class<? extends SingletonElectionCommand> getJavaClass() {
return SingletonElectionCommand.class;
}
}
| 2,979
| 36.721519
| 108
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/PrimaryProxyService.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CompletionException;
import java.util.concurrent.CompletionStage;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.StartContext;
import org.jboss.msc.service.StopContext;
import org.wildfly.clustering.dispatcher.CommandDispatcherException;
import org.wildfly.clustering.group.Node;
/**
* Service that proxies the value from the primary node.
* @author Paul Ferraro
*/
@Deprecated
public class PrimaryProxyService<T> implements Service<T> {
private final Supplier<PrimaryProxyContext<T>> contextFactory;
private volatile boolean started = false;
public PrimaryProxyService(Supplier<PrimaryProxyContext<T>> contextFactory) {
this.contextFactory = contextFactory;
}
@Override
public T getValue() {
PrimaryProxyContext<T> context = this.contextFactory.get();
if (!this.started) {
throw SingletonLogger.ROOT_LOGGER.notStarted(context.getServiceName().getCanonicalName());
}
try {
Map<Node, CompletionStage<Optional<T>>> responses = context.getCommandDispatcher().executeOnGroup(new SingletonValueCommand<>());
// Prune non-primary (i.e. null) results
Map<Node, Optional<T>> results = new HashMap<>();
try {
for (Map.Entry<Node, CompletionStage<Optional<T>>> entry : responses.entrySet()) {
try {
Optional<T> response = entry.getValue().toCompletableFuture().join();
if (response != null) {
results.put(entry.getKey(), response);
}
} catch (CancellationException e) {
// Ignore
}
}
} catch (CompletionException e) {
throw new IllegalArgumentException(e);
}
// We expect only 1 result
if (results.size() > 1) {
// This would mean there are multiple primary nodes!
throw SingletonLogger.ROOT_LOGGER.multiplePrimaryProvidersDetected(context.getServiceName().getCanonicalName(), results.keySet());
}
Iterator<Optional<T>> values = results.values().iterator();
if (!values.hasNext()) {
throw SingletonLogger.ROOT_LOGGER.noResponseFromPrimary(context.getServiceName().getCanonicalName());
}
return values.next().orElse(null);
} catch (CommandDispatcherException e) {
throw new IllegalArgumentException(e);
}
}
@Override
public void start(StartContext context) {
this.started = true;
}
@Override
public void stop(StopContext context) {
this.started = false;
}
}
| 4,053
| 37.980769
| 146
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/ServiceLifecycle.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import org.jboss.msc.service.LifecycleEvent;
import org.jboss.msc.service.LifecycleListener;
import org.jboss.msc.service.ServiceController;
import org.wildfly.clustering.service.CountDownLifecycleListener;
import org.jboss.msc.service.ServiceController.Mode;
import org.jboss.msc.service.ServiceController.State;
import org.jboss.msc.service.ServiceNotFoundException;
/**
* Starts/stops a given {@link ServiceController}.
* @author Paul Ferraro
*/
public class ServiceLifecycle implements Lifecycle {
private enum Transition {
START(EnumSet.of(State.UP, State.START_FAILED, State.REMOVED), LifecycleEvent.DOWN),
STOP(EnumSet.of(State.DOWN, State.REMOVED), LifecycleEvent.UP),
;
Set<State> targetStates;
Set<LifecycleEvent> targetEvents;
Map<Mode, Mode> modeTransitions;
Transition(Set<State> targetStates, LifecycleEvent sourceEvent) {
this.targetStates = targetStates;
this.targetEvents = EnumSet.complementOf(EnumSet.of(sourceEvent));
this.modeTransitions = new EnumMap<>(Mode.class);
boolean up = this.targetStates.contains(State.UP);
this.modeTransitions.put(up ? Mode.NEVER : Mode.ACTIVE, up ? Mode.ACTIVE : Mode.NEVER);
this.modeTransitions.put(up ? Mode.ON_DEMAND : Mode.PASSIVE, up ? Mode.PASSIVE : Mode.ON_DEMAND);
}
}
private final ServiceController<?> controller;
public ServiceLifecycle(ServiceController<?> controller) {
this.controller = controller;
}
@Override
public void start() {
this.transition(Transition.START);
}
@Override
public void stop() {
this.transition(Transition.STOP);
}
private void transition(Transition transition) {
// Short-circuit if the service is already at the target state
if (this.isComplete(transition)) return;
CountDownLatch latch = new CountDownLatch(1);
LifecycleListener listener = new CountDownLifecycleListener(latch, transition.targetEvents);
this.controller.addListener(listener);
try {
if (this.isComplete(transition)) return;
// Force service to transition to desired state
Mode currentMode = this.controller.getMode();
if (currentMode == ServiceController.Mode.REMOVE) {
throw new IllegalStateException(new ServiceNotFoundException(this.controller.getName().getCanonicalName()));
}
Mode targetMode = transition.modeTransitions.get(currentMode);
if (targetMode == null) {
throw new IllegalStateException(currentMode.name());
}
this.controller.setMode(targetMode);
latch.await();
if (this.controller.getState() == State.START_FAILED) {
throw new IllegalStateException(this.controller.getStartException());
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
this.controller.removeListener(listener);
}
}
private boolean isComplete(Transition transition) {
State state = this.controller.getState();
if (transition.targetStates.contains(state)) {
if (state == State.START_FAILED) {
throw new IllegalStateException(this.controller.getStartException());
}
return true;
}
return false;
}
}
| 4,696
| 36.879032
| 124
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/SingletonValueCommand.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.Optional;
import org.wildfly.clustering.dispatcher.Command;
public class SingletonValueCommand<T> implements Command<Optional<T>, LegacySingletonContext<T>> {
private static final long serialVersionUID = -2849349352107418635L;
@Override
public Optional<T> execute(LegacySingletonContext<T> context) {
return context.getLocalValue();
}
}
| 1,454
| 39.416667
| 98
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/DistributedSingletonServiceBuilder.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.function.Supplier;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.provider.ServiceProviderRegistry;
import org.wildfly.clustering.server.dispatcher.CommandDispatcherFactory;
import org.wildfly.clustering.service.CompositeDependency;
import org.wildfly.clustering.service.SimpleServiceNameProvider;
import org.wildfly.clustering.service.SupplierDependency;
import org.wildfly.clustering.singleton.SingletonElectionListener;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
import org.wildfly.clustering.singleton.SingletonService;
import org.wildfly.clustering.singleton.SingletonServiceBuilder;
import org.wildfly.clustering.singleton.election.SimpleSingletonElectionPolicy;
/**
* Distributed {@link SingletonServiceBuilder} implementation that uses JBoss MSC 1.3.x service installation.
* @author Paul Ferraro
*/
@Deprecated
public class DistributedSingletonServiceBuilder<T> extends SimpleServiceNameProvider implements SingletonServiceBuilder<T>, DistributedSingletonServiceContext, Supplier<Group> {
private final SupplierDependency<ServiceProviderRegistry<ServiceName>> registry;
private final SupplierDependency<CommandDispatcherFactory> dispatcherFactory;
private final Service<T> primaryService;
private final Service<T> backupService;
private volatile SingletonElectionPolicy electionPolicy = new SimpleSingletonElectionPolicy();
private volatile SingletonElectionListener electionListener;
private volatile int quorum = 1;
public DistributedSingletonServiceBuilder(ServiceName serviceName, Service<T> primaryService, Service<T> backupService, DistributedSingletonServiceConfiguratorContext context) {
super(serviceName);
this.registry = context.getServiceProviderRegistryDependency();
this.dispatcherFactory = context.getCommandDispatcherFactoryDependency();
this.primaryService = primaryService;
this.backupService = backupService;
this.electionListener = new DefaultSingletonElectionListener(serviceName, this);
}
@Override
public Group get() {
return this.registry.get().getGroup();
}
@Override
public ServiceBuilder<T> build(ServiceTarget target) {
SingletonService<T> service = new LegacyDistributedSingletonService<>(this, this.primaryService, this.backupService);
ServiceBuilder<T> installer = new AsynchronousServiceBuilder<>(this.getServiceName(), service).build(target);
return new CompositeDependency(this.registry, this.dispatcherFactory).register(installer);
}
@Override
public SingletonServiceBuilder<T> requireQuorum(int quorum) {
if (quorum < 1) {
throw SingletonLogger.ROOT_LOGGER.invalidQuorum(quorum);
}
this.quorum = quorum;
return this;
}
@Override
public SingletonServiceBuilder<T> electionPolicy(SingletonElectionPolicy electionPolicy) {
this.electionPolicy = electionPolicy;
return this;
}
@Override
public SingletonServiceBuilder<T> electionListener(SingletonElectionListener listener) {
this.electionListener = listener;
return this;
}
@Override
public Supplier<ServiceProviderRegistry<ServiceName>> getServiceProviderRegistry() {
return this.registry;
}
@Override
public Supplier<CommandDispatcherFactory> getCommandDispatcherFactory() {
return this.dispatcherFactory;
}
@Override
public SingletonElectionPolicy getElectionPolicy() {
return this.electionPolicy;
}
@Override
public SingletonElectionListener getElectionListener() {
return this.electionListener;
}
@Override
public int getQuorum() {
return this.quorum;
}
}
| 5,031
| 38.936508
| 181
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalLegacySingletonService.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.jboss.msc.service.Service;
import org.wildfly.clustering.singleton.SingletonService;
/**
* Local {@link SingletonService} implementation created using JBoss MSC 1.3.x service installation.
* @author Paul Ferraro
*/
@Deprecated
public class LocalLegacySingletonService<T> extends LocalSingletonService implements SingletonService<T> {
private final Service<T> service;
public LocalLegacySingletonService(Service<T> service, LocalSingletonServiceContext context) {
super(service, context);
this.service = service;
}
@Override
public T getValue() {
return this.service.getValue();
}
}
| 1,722
| 35.659574
| 106
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/StartCommand.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.wildfly.clustering.dispatcher.Command;
/**
* Command to start a singleton service.
* @author Paul Ferraro
*/
public class StartCommand implements Command<Void, Lifecycle> {
private static final long serialVersionUID = 3194143912789013071L;
@Override
public Void execute(Lifecycle context) throws Exception {
context.start();
return null;
}
}
| 1,464
| 35.625
| 70
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LegacyDistributedSingletonService.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.ServiceController;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceRegistry;
import org.jboss.msc.service.ServiceTarget;
import org.jboss.msc.service.StartContext;
import org.jboss.msc.service.StartException;
import org.jboss.msc.service.StopContext;
import org.wildfly.clustering.dispatcher.CommandDispatcher;
import org.wildfly.clustering.singleton.SingletonService;
/**
* Distributed {@link SingletonService} implementation that uses JBoss MSC 1.3.x service installation.
* Decorates an MSC service ensuring that it is only started on one node in the cluster at any given time.
* @author Paul Ferraro
*/
@Deprecated
public class LegacyDistributedSingletonService<T> extends AbstractDistributedSingletonService<LegacySingletonContext<T>> implements SingletonService<T>, LegacySingletonContext<T>, PrimaryProxyContext<T> {
private final ServiceName name;
private volatile boolean started = false;
private volatile ServiceController<T> primaryController;
private volatile ServiceController<T> backupController;
public LegacyDistributedSingletonService(DistributedSingletonServiceContext context, Service<T> primaryService, Service<T> backupService) {
this(context, primaryService, backupService, new LazySupplier<>());
}
private LegacyDistributedSingletonService(DistributedSingletonServiceContext context, Service<T> primaryService, Service<T> backupService, LazySupplier<PrimaryProxyContext<T>> contextFactory) {
super(context, new ServiceLifecycleFactory<>(context.getServiceName(), primaryService, (backupService != null) ? backupService : new PrimaryProxyService<>(contextFactory)));
contextFactory.accept(this);
this.name = context.getServiceName();
}
@Override
public ServiceName getServiceName() {
return this.name;
}
@Override
public LegacySingletonContext<T> get() {
return this;
}
@SuppressWarnings("unchecked")
@Override
public void start(StartContext context) throws StartException {
super.start(context);
ServiceRegistry registry = context.getController().getServiceContainer();
this.primaryController = (ServiceController<T>) registry.getService(this.getServiceName().append("primary"));
this.backupController = (ServiceController<T>) registry.getService(this.getServiceName().append("backup"));
this.started = true;
}
@Override
public void stop(StopContext context) {
this.started = false;
super.stop(context);
}
@Override
public T getValue() {
while (this.started) {
try {
return (this.isPrimary() ? this.primaryController : this.backupController).getValue();
} catch (IllegalStateException e) {
// Verify whether ISE is due to unmet quorum in the previous election
if (this.getServiceProviderRegistration().getProviders().size() < this.getQuorum()) {
throw SingletonLogger.ROOT_LOGGER.notStarted(this.getServiceName().getCanonicalName());
}
if (Thread.currentThread().isInterrupted()) {
throw e;
}
// Otherwise, we're in the midst of a new election, so just try again
Thread.yield();
}
}
throw SingletonLogger.ROOT_LOGGER.notStarted(this.getServiceName().getCanonicalName());
}
@Override
public CommandDispatcher<LegacySingletonContext<T>> getCommandDispatcher() {
return super.getCommandDispatcher();
}
@Override
public Optional<T> getLocalValue() {
try {
return this.isPrimary() ? Optional.ofNullable(this.primaryController.getValue()) : null;
} catch (IllegalStateException e) {
// This might happen if primary service has not yet started, or if node is no longer the primary node
return null;
}
}
static class LazySupplier<T> implements Supplier<T>, Consumer<T> {
private volatile T value;
@Override
public void accept(T value) {
this.value = value;
}
@Override
public T get() {
return this.value;
}
}
private static class ServiceLifecycleFactory<T> implements Function<ServiceTarget, Lifecycle> {
private final ServiceName name;
private final Service<T> primaryService;
private final Service<T> backupService;
ServiceLifecycleFactory(ServiceName name, Service<T> primaryService, Service<T> backupService) {
this.name = name;
this.primaryService = primaryService;
this.backupService = backupService;
}
@Override
public Lifecycle apply(ServiceTarget target) {
Lifecycle primaryLifecycle = new ServiceLifecycle(target.addService(this.name.append("primary"), this.primaryService).setInitialMode(ServiceController.Mode.NEVER).install());
Lifecycle backupLifecycle = new ServiceLifecycle(target.addService(this.name.append("backup"), this.backupService).setInitialMode(ServiceController.Mode.ACTIVE).install());
return new PrimaryBackupLifecycle(primaryLifecycle, backupLifecycle);
}
}
private static class PrimaryBackupLifecycle implements Lifecycle {
private final Lifecycle primaryLifecycle;
private final Lifecycle backupLifecycle;
PrimaryBackupLifecycle(Lifecycle primaryLifecycle, Lifecycle backupLifecycle) {
this.primaryLifecycle = primaryLifecycle;
this.backupLifecycle = backupLifecycle;
}
@Override
public void start() {
this.backupLifecycle.stop();
this.primaryLifecycle.start();
}
@Override
public void stop() {
this.primaryLifecycle.stop();
this.backupLifecycle.start();
}
}
}
| 7,253
| 39.077348
| 204
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/SingletonLogger.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2011, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import static org.jboss.logging.Logger.Level.ERROR;
import static org.jboss.logging.Logger.Level.INFO;
import static org.jboss.logging.Logger.Level.WARN;
import java.util.Collection;
import org.jboss.logging.BasicLogger;
import org.jboss.logging.Logger;
import org.jboss.logging.annotations.Cause;
import org.jboss.logging.annotations.LogMessage;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageLogger;
import org.jboss.msc.service.StartException;
import org.wildfly.clustering.group.Node;
/**
* @author <a href="mailto:pferraro@redhat.com">Paul Ferraro</a>
*/
@MessageLogger(projectCode = "WFLYCLSN", length = 4)
public interface SingletonLogger extends BasicLogger {
String ROOT_LOGGER_CATEGORY = "org.wildfly.clustering.singleton.server";
/**
* The root logger.
*/
SingletonLogger ROOT_LOGGER = Logger.getMessageLogger(SingletonLogger.class, ROOT_LOGGER_CATEGORY);
@LogMessage(level = INFO)
@Message(id = 1, value = "This node will now operate as the singleton provider of the %s service")
void startSingleton(String service);
@LogMessage(level = INFO)
@Message(id = 2, value = "This node will no longer operate as the singleton provider of the %s service")
void stopSingleton(String service);
@LogMessage(level = INFO)
@Message(id = 3, value = "%s elected as the singleton provider of the %s service")
void elected(String node, String service);
@Message(id = 4, value = "No response received from primary provider of the %s service, retrying...")
IllegalStateException noResponseFromPrimary(String service);
@LogMessage(level = ERROR)
@Message(id = 5, value = "Failed to start %s service")
void serviceStartFailed(@Cause StartException e, String service);
@LogMessage(level = WARN)
@Message(id = 6, value = "Failed to reach quorum of %2$d for %1$s service. No primary singleton provider will be elected.")
void quorumNotReached(String service, int quorum);
@LogMessage(level = INFO)
@Message(id = 7, value = "Just reached required quorum of %2$d for %1$s service. If this cluster loses another member, no node will be chosen to provide this service.")
void quorumJustReached(String service, int quorum);
@Message(id = 8, value = "Detected multiple primary providers for %s service: %s")
IllegalArgumentException multiplePrimaryProvidersDetected(String serviceName, Collection<Node> nodes);
@Message(id = 9, value = "Singleton service %s is not started.")
IllegalStateException notStarted(String serviceName);
@LogMessage(level = WARN)
@Message(id = 10, value = "No node was elected as the singleton provider of the %s service")
void noPrimaryElected(String service);
@Message(id = 11, value = "Specified quorum %d must be greater than zero")
IllegalArgumentException invalidQuorum(int quorum);
}
| 3,970
| 42.637363
| 172
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/AsynchronousServiceBuilder.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2011, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionException;
import java.util.function.Supplier;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.jboss.msc.service.StartContext;
import org.jboss.msc.service.StartException;
import org.jboss.msc.service.StopContext;
import org.jboss.msc.value.InjectedValue;
import org.wildfly.clustering.service.AsyncServiceConfigurator;
import org.wildfly.clustering.service.Builder;
/**
* Builder for asynchronously started/stopped services.
* @author Paul Ferraro
* @param <T> the type of value provided by services built by this builder
* @deprecated Replaced by {@link AsyncServiceConfigurator}.
*/
@Deprecated
public class AsynchronousServiceBuilder<T> implements Builder<T>, Service<T>, Supplier<Service<T>> {
private static final ServiceName EXECUTOR_SERVICE_NAME = ServiceName.JBOSS.append("as", "server-executor");
private final InjectedValue<ExecutorService> executor = new InjectedValue<>();
private final Service<T> service;
private final ServiceName name;
private volatile boolean startAsynchronously = true;
private volatile boolean stopAsynchronously = true;
/**
* Constructs a new builder for building asynchronous service
* @param name the target service name
* @param service the target service
*/
public AsynchronousServiceBuilder(ServiceName name, Service<T> service) {
this.name = name;
this.service = service;
}
@Override
public ServiceName getServiceName() {
return this.name;
}
@Override
public ServiceBuilder<T> build(ServiceTarget target) {
return target.addService(this.name, this).addDependency(EXECUTOR_SERVICE_NAME, ExecutorService.class, this.executor);
}
/**
* Return the underlying service for this builder
* @return an MSC service
*/
@Override
public Service<T> get() {
return this.service;
}
/**
* Indicates that this service should *not* be started asynchronously.
* @return a reference to this builder
*/
public AsynchronousServiceBuilder<T> startSynchronously() {
this.startAsynchronously = false;
return this;
}
/**
* Indicates that this service should *not* be stopped asynchronously.
* @return a reference to this builder
*/
public AsynchronousServiceBuilder<T> stopSynchronously() {
this.stopAsynchronously = false;
return this;
}
@Override
public T getValue() {
return this.service.getValue();
}
@Override
public void start(final StartContext context) throws StartException {
if (this.startAsynchronously) {
Runnable task = () -> {
try {
this.service.start(context);
context.complete();
} catch (StartException e) {
context.failed(e);
} catch (Throwable e) {
context.failed(new StartException(e));
}
};
try {
this.executor.getValue().execute(task);
} catch (RejectedExecutionException e) {
task.run();
} finally {
context.asynchronous();
}
} else {
this.service.start(context);
}
}
@Override
public void stop(final StopContext context) {
if (this.stopAsynchronously) {
Runnable task = () -> {
try {
this.service.stop(context);
} finally {
context.complete();
}
};
try {
this.executor.getValue().execute(task);
} catch (RejectedExecutionException e) {
task.run();
} finally {
context.asynchronous();
}
} else {
this.service.stop(context);
}
}
}
| 5,208
| 32.606452
| 125
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/DefaultSingletonElectionListener.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Supplier;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.singleton.SingletonElectionListener;
/**
* Default singleton election listener that logs the results of the singleton election.
* @author Paul Ferraro
*/
public class DefaultSingletonElectionListener implements SingletonElectionListener {
private final ServiceName name;
private final Supplier<Group> group;
private final AtomicReference<Node> primaryMember = new AtomicReference<>();
public DefaultSingletonElectionListener(ServiceName name, Supplier<Group> group) {
this.name = name;
this.group = group;
}
@Override
public void elected(List<Node> candidateMembers, Node electedMember) {
Node localMember = this.group.get().getLocalMember();
Node previousElectedMember = this.primaryMember.getAndSet(electedMember);
if (electedMember != null) {
SingletonLogger.ROOT_LOGGER.elected(electedMember.getName(), this.name.getCanonicalName());
} else {
SingletonLogger.ROOT_LOGGER.noPrimaryElected(this.name.getCanonicalName());
}
if (localMember.equals(electedMember)) {
SingletonLogger.ROOT_LOGGER.startSingleton(this.name.getCanonicalName());
} else if (localMember.equals(previousElectedMember)) {
SingletonLogger.ROOT_LOGGER.stopSingleton(this.name.getCanonicalName());
}
}
}
| 2,686
| 39.712121
| 103
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/PrimaryProviderCommand.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.wildfly.clustering.dispatcher.Command;
import org.wildfly.clustering.singleton.Singleton;
/**
* @author Paul Ferraro
*/
public class PrimaryProviderCommand implements Command<Boolean, Singleton> {
private static final long serialVersionUID = 3194143912789013072L;
@Override
public Boolean execute(Singleton singleton) {
return singleton.isPrimary();
}
}
| 1,467
| 36.641026
| 76
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/DistributedSingletonServiceConfiguratorContext.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.provider.ServiceProviderRegistry;
import org.wildfly.clustering.server.dispatcher.CommandDispatcherFactory;
import org.wildfly.clustering.service.SupplierDependency;
/**
* Context for building singleton services.
* @author Paul Ferraro
*/
public interface DistributedSingletonServiceConfiguratorContext {
SupplierDependency<ServiceProviderRegistry<ServiceName>> getServiceProviderRegistryDependency();
SupplierDependency<CommandDispatcherFactory> getCommandDispatcherFactoryDependency();
}
| 1,648
| 42.394737
| 100
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/DistributedSingletonServiceConfigurator.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.AbstractMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Supplier;
import org.jboss.msc.Service;
import org.jboss.msc.service.DelegatingServiceBuilder;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceController;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.provider.ServiceProviderRegistry;
import org.wildfly.clustering.server.dispatcher.CommandDispatcherFactory;
import org.wildfly.clustering.service.AsyncServiceConfigurator;
import org.wildfly.clustering.service.CompositeDependency;
import org.wildfly.clustering.service.SimpleServiceNameProvider;
import org.wildfly.clustering.service.SupplierDependency;
import org.wildfly.clustering.singleton.Singleton;
import org.wildfly.clustering.singleton.SingletonElectionListener;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
import org.wildfly.clustering.singleton.election.SimpleSingletonElectionPolicy;
import org.wildfly.clustering.singleton.service.SingletonServiceBuilder;
import org.wildfly.clustering.singleton.service.SingletonServiceConfigurator;
/**
* Distributed {@link SingletonServiceConfigurator} implementation that uses JBoss MSC 1.4.x service installation.
* @author Paul Ferraro
*/
public class DistributedSingletonServiceConfigurator extends SimpleServiceNameProvider implements SingletonServiceConfigurator, DistributedSingletonServiceContext, Supplier<Group> {
private final SupplierDependency<ServiceProviderRegistry<ServiceName>> registry;
private final SupplierDependency<CommandDispatcherFactory> dispatcherFactory;
private volatile SingletonElectionPolicy electionPolicy = new SimpleSingletonElectionPolicy();
private volatile SingletonElectionListener electionListener;
private volatile int quorum = 1;
public DistributedSingletonServiceConfigurator(ServiceName name, DistributedSingletonServiceConfiguratorContext context) {
super(name);
this.registry = context.getServiceProviderRegistryDependency();
this.dispatcherFactory = context.getCommandDispatcherFactoryDependency();
this.electionListener = new DefaultSingletonElectionListener(name, this);
}
@Override
public Group get() {
return this.registry.get().getGroup();
}
@Override
public SingletonServiceBuilder<?> build(ServiceTarget target) {
ServiceName name = this.getServiceName().append("singleton");
ServiceBuilder<?> builder = new AsyncServiceConfigurator(name).build(target);
Consumer<Singleton> singleton = builder.provides(name);
return new DistributedSingletonServiceBuilder<>(this, new CompositeDependency(this.registry, this.dispatcherFactory).register(builder), singleton);
}
@Override
public SingletonServiceConfigurator requireQuorum(int quorum) {
this.quorum = quorum;
return this;
}
@Override
public SingletonServiceConfigurator electionPolicy(SingletonElectionPolicy policy) {
this.electionPolicy = policy;
return this;
}
@Override
public SingletonServiceConfigurator electionListener(SingletonElectionListener listener) {
this.electionListener = listener;
return this;
}
@Override
public Supplier<ServiceProviderRegistry<ServiceName>> getServiceProviderRegistry() {
return this.registry;
}
@Override
public Supplier<CommandDispatcherFactory> getCommandDispatcherFactory() {
return this.dispatcherFactory;
}
@Override
public SingletonElectionPolicy getElectionPolicy() {
return this.electionPolicy;
}
@Override
public SingletonElectionListener getElectionListener() {
return this.electionListener;
}
@Override
public int getQuorum() {
return this.quorum;
}
private static class DistributedSingletonServiceBuilder<T> extends DelegatingServiceBuilder<T> implements SingletonServiceBuilder<T> {
private final DistributedSingletonServiceContext context;
private final Consumer<Singleton> singleton;
private final List<Map.Entry<ServiceName[], DeferredInjector<?>>> injectors = new LinkedList<>();
private Service service = Service.NULL;
DistributedSingletonServiceBuilder(DistributedSingletonServiceContext context, ServiceBuilder<T> builder, Consumer<Singleton> singleton) {
super(builder);
this.context = context;
this.singleton = singleton;
}
@Override
public <V> Consumer<V> provides(ServiceName... names) {
DeferredInjector<V> injector = new DeferredInjector<>();
this.injectors.add(new AbstractMap.SimpleImmutableEntry<>(names, injector));
return injector;
}
@Override
public ServiceBuilder<T> setInstance(Service service) {
this.service = service;
return this;
}
@Override
public ServiceController<T> install() {
return this.getDelegate().setInstance(new DistributedSingletonService(this.context, this.service, this.singleton, this.injectors)).install();
}
}
}
| 6,432
| 39.20625
| 181
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalSingletonServiceConfiguratorFactory.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.service.ServiceSupplierDependency;
import org.wildfly.clustering.service.SupplierDependency;
import org.wildfly.clustering.singleton.service.SingletonServiceConfigurator;
import org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory;
/**
* Factory for creating local {@link SingletonServiceConfigurator} instances.
* @author Paul Ferraro
*/
public class LocalSingletonServiceConfiguratorFactory implements SingletonServiceConfiguratorFactory, LocalSingletonServiceConfiguratorContext {
private final LocalSingletonServiceConfiguratorFactoryContext context;
public LocalSingletonServiceConfiguratorFactory(LocalSingletonServiceConfiguratorFactoryContext context) {
this.context = context;
}
@Override
public SingletonServiceConfigurator createSingletonServiceConfigurator(ServiceName name) {
return new LocalSingletonServiceConfigurator(name, this);
}
@Override
public SupplierDependency<Group> getGroupDependency() {
return new ServiceSupplierDependency<>(this.context.getGroupServiceName());
}
}
| 2,276
| 41.166667
| 144
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/DistributedSingletonServiceContext.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.function.Supplier;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.provider.ServiceProviderRegistry;
import org.wildfly.clustering.server.dispatcher.CommandDispatcherFactory;
import org.wildfly.clustering.singleton.SingletonElectionPolicy;
/**
* @author Paul Ferraro
*/
public interface DistributedSingletonServiceContext extends SingletonServiceContext {
Supplier<ServiceProviderRegistry<ServiceName>> getServiceProviderRegistry();
Supplier<CommandDispatcherFactory> getCommandDispatcherFactory();
SingletonElectionPolicy getElectionPolicy();
int getQuorum();
}
| 1,698
| 40.439024
| 85
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/DistributedSingletonServiceBuilderFactory.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.jboss.as.clustering.msc.InjectedValueDependency;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.provider.ServiceProviderRegistry;
import org.wildfly.clustering.server.dispatcher.CommandDispatcherFactory;
import org.wildfly.clustering.service.SupplierDependency;
import org.wildfly.clustering.singleton.SingletonServiceBuilder;
import org.wildfly.clustering.singleton.SingletonServiceBuilderFactory;
/**
* Factory for creating distributed {@link SingletonServiceBuilder} instances.
* @author Paul Ferraro
*/
@Deprecated
public class DistributedSingletonServiceBuilderFactory extends DistributedSingletonServiceConfiguratorFactory implements SingletonServiceBuilderFactory {
private final DistributedSingletonServiceConfiguratorContext context;
public DistributedSingletonServiceBuilderFactory(DistributedSingletonServiceConfiguratorFactoryContext context) {
super(context);
this.context = new LegacyDistributedSingletonServiceConfiguratorContext(context);
}
@Override
public <T> SingletonServiceBuilder<T> createSingletonServiceBuilder(ServiceName name, Service<T> service) {
return this.createSingletonServiceBuilder(name, service, null);
}
@Override
public <T> SingletonServiceBuilder<T> createSingletonServiceBuilder(ServiceName name, Service<T> primaryService, Service<T> backupService) {
return new DistributedSingletonServiceBuilder<>(name, primaryService, backupService, this.context);
}
private class LegacyDistributedSingletonServiceConfiguratorContext implements DistributedSingletonServiceConfiguratorContext {
private final DistributedSingletonServiceConfiguratorFactoryContext context;
LegacyDistributedSingletonServiceConfiguratorContext(DistributedSingletonServiceConfiguratorFactoryContext context) {
this.context = context;
}
@SuppressWarnings("unchecked")
@Override
public SupplierDependency<ServiceProviderRegistry<ServiceName>> getServiceProviderRegistryDependency() {
return new InjectedValueDependency<>(this.context.getServiceProviderRegistryServiceName(), (Class<ServiceProviderRegistry<ServiceName>>) (Class<?>) ServiceProviderRegistry.class);
}
@Override
public SupplierDependency<CommandDispatcherFactory> getCommandDispatcherFactoryDependency() {
return new InjectedValueDependency<>(this.context.getCommandDispatcherFactoryServiceName(), CommandDispatcherFactory.class);
}
}
}
| 3,656
| 47.118421
| 191
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/SingletonContext.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.wildfly.clustering.singleton.Singleton;
import org.wildfly.clustering.singleton.SingletonElectionListener;
/**
* @author Paul Ferraro
*/
public interface SingletonContext extends Lifecycle, Singleton, SingletonElectionListener {
}
| 1,319
| 39
| 91
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalSingletonServiceContext.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.function.Supplier;
import org.wildfly.clustering.group.Group;
/**
* Context for local singleton services.
* @author Paul Ferraro
*/
public interface LocalSingletonServiceContext extends SingletonServiceContext {
Supplier<Group> getGroup();
}
| 1,342
| 36.305556
| 79
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/DistributedSingletonService.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
import org.jboss.msc.Service;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceController;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.jboss.msc.service.StartContext;
import org.jboss.msc.service.StartException;
import org.wildfly.clustering.singleton.Singleton;
/**
* Distributed {@link org.wildfly.clustering.singleton.service.SingletonService} implementation that uses JBoss MSC 1.4.x service installation.
* @author Paul Ferraro
*/
public class DistributedSingletonService extends AbstractDistributedSingletonService<SingletonContext> {
private final Consumer<Singleton> singleton;
public DistributedSingletonService(DistributedSingletonServiceContext context, Service service, Consumer<Singleton> singleton, List<Map.Entry<ServiceName[], DeferredInjector<?>>> injectors) {
super(context, new PrimaryServiceLifecycleFactory(context.getServiceName(), service, injectors));
this.singleton = singleton;
}
@Override
public void start(StartContext context) throws StartException {
super.start(context);
this.singleton.accept(this);
}
@Override
public SingletonContext get() {
return this;
}
private static class PrimaryServiceLifecycleFactory implements Function<ServiceTarget, Lifecycle> {
private final ServiceName name;
private final Service service;
private final List<Map.Entry<ServiceName[], DeferredInjector<?>>> injectors;
PrimaryServiceLifecycleFactory(ServiceName name, Service service, List<Map.Entry<ServiceName[], DeferredInjector<?>>> injectors) {
this.name = name;
this.service = service;
this.injectors = injectors;
}
@Override
public Lifecycle apply(ServiceTarget target) {
ServiceBuilder<?> builder = target.addService(this.name);
for (Map.Entry<ServiceName[], DeferredInjector<?>> entry : this.injectors) {
entry.getValue().setConsumer(builder.provides(entry.getKey()));
}
return new ServiceLifecycle(builder.setInstance(this.service).setInitialMode(ServiceController.Mode.NEVER).install());
}
}
}
| 3,452
| 40.107143
| 195
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/SingletonSerializationContextInitializerProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2021, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.infinispan.protostream.SerializationContext;
import org.infinispan.protostream.SerializationContextInitializer;
import org.wildfly.clustering.marshalling.protostream.AbstractSerializationContextInitializer;
import org.wildfly.clustering.marshalling.protostream.ProviderSerializationContextInitializer;
import org.wildfly.clustering.marshalling.protostream.SerializationContextInitializerProvider;
import org.wildfly.clustering.marshalling.protostream.ValueMarshaller;
/**
* Provider of the {@link SerializationContextInitializer} instances for this module.
* @author Paul Ferraro
*/
public enum SingletonSerializationContextInitializerProvider implements SerializationContextInitializerProvider {
SERVICE(new ProviderSerializationContextInitializer<>("org.jboss.msc.service.proto", ServiceMarshallerProvider.class)),
SINGLETON(new AbstractSerializationContextInitializer() {
@Override
public void registerMarshallers(SerializationContext context) {
context.registerMarshaller(new SingletonElectionCommandMarshaller());
context.registerMarshaller(new ValueMarshaller<>(new StartCommand()));
context.registerMarshaller(new ValueMarshaller<>(new StopCommand()));
context.registerMarshaller(new ValueMarshaller<>(new PrimaryProviderCommand()));
context.registerMarshaller(new ValueMarshaller<>(new SingletonValueCommand<>()));
}
}),
;
private final SerializationContextInitializer initializer;
SingletonSerializationContextInitializerProvider(SerializationContextInitializer initializer) {
this.initializer = initializer;
}
@Override
public SerializationContextInitializer getInitializer() {
return this.initializer;
}
}
| 2,848
| 46.483333
| 123
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/PrimaryProxyContext.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.wildfly.clustering.dispatcher.CommandDispatcher;
import org.wildfly.clustering.service.ServiceNameProvider;
/**
* @author Paul Ferraro
*/
public interface PrimaryProxyContext<T> extends ServiceNameProvider {
CommandDispatcher<LegacySingletonContext<T>> getCommandDispatcher();
}
| 1,371
| 39.352941
| 72
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalSingletonServiceConfiguratorFactoryServiceConfigurator.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2014, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.io.Serializable;
import java.util.function.Consumer;
import org.jboss.as.clustering.controller.CapabilityServiceConfigurator;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.msc.Service;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.wildfly.clustering.server.service.ClusteringCacheRequirement;
import org.wildfly.clustering.service.ServiceConfigurator;
import org.wildfly.clustering.service.SimpleServiceNameProvider;
import org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory;
/**
* Configures a service providing a local {@link org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory}.
* @author Paul Ferraro
*/
public class LocalSingletonServiceConfiguratorFactoryServiceConfigurator<T extends Serializable> extends SimpleServiceNameProvider implements CapabilityServiceConfigurator, LocalSingletonServiceConfiguratorFactoryContext {
private final String containerName;
private final String cacheName;
private volatile ServiceName groupServiceName;
public LocalSingletonServiceConfiguratorFactoryServiceConfigurator(ServiceName name, String containerName, String cacheName) {
super(name);
this.containerName = containerName;
this.cacheName = cacheName;
}
@Override
public ServiceConfigurator configure(CapabilityServiceSupport support) {
this.groupServiceName = ClusteringCacheRequirement.GROUP.getServiceName(support, this.containerName, this.cacheName);
return this;
}
@Override
public ServiceBuilder<?> build(ServiceTarget target) {
ServiceBuilder<?> builder = target.addService(this.getServiceName());
Consumer<SingletonServiceConfiguratorFactory> factory = builder.provides(this.getServiceName());
Service service = Service.newInstance(factory, new LocalSingletonServiceBuilderFactory(this));
return builder.setInstance(service);
}
@Override
public ServiceName getGroupServiceName() {
return this.groupServiceName;
}
}
| 3,240
| 42.213333
| 222
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LegacySingletonContext.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.Optional;
/**
* Context for singleton commands.
* @author Paul Ferraro
*/
public interface LegacySingletonContext<T> extends SingletonContext {
Optional<T> getLocalValue();
}
| 1,274
| 36.5
| 70
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/SingletonElectionCommand.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.List;
import org.wildfly.clustering.dispatcher.Command;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.singleton.SingletonElectionListener;
/**
* @author Paul Ferraro
*/
public class SingletonElectionCommand implements Command<Void, SingletonElectionListener> {
private static final long serialVersionUID = 8457549139382922406L;
private final List<Node> candidates;
private final Integer index;
public SingletonElectionCommand(List<Node> candidates, Node elected) {
this(candidates, (elected != null) ? candidates.indexOf(elected) : null);
}
SingletonElectionCommand(List<Node> candidates, Integer index) {
this.candidates = candidates;
this.index = index;
}
List<Node> getCandidates() {
return this.candidates;
}
Integer getIndex() {
return this.index;
}
@Override
public Void execute(SingletonElectionListener context) {
context.elected(this.candidates, (this.index != null) ? this.candidates.get(this.index) : null);
return null;
}
}
| 2,175
| 33.539683
| 104
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/ServiceNameFormatter.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.jboss.msc.service.ServiceName;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.marshalling.Externalizer;
import org.wildfly.clustering.marshalling.spi.Formatter;
import org.wildfly.clustering.marshalling.spi.SimpleFormatter;
import org.wildfly.clustering.marshalling.spi.StringExternalizer;
/**
* {@link Externalizer} for a {@link ServiceName}.
* @author Paul Ferraro
*/
@MetaInfServices(Formatter.class)
public class ServiceNameFormatter extends SimpleFormatter<ServiceName> {
public ServiceNameFormatter() {
super(ServiceName.class, ServiceName::parse, ServiceName::getCanonicalName);
}
@MetaInfServices(Externalizer.class)
public static class ServiceNameExternalizer extends StringExternalizer<ServiceName> {
public ServiceNameExternalizer() {
super(new ServiceNameFormatter());
}
}
}
| 1,952
| 38.857143
| 89
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/IdentitySingletonServiceBuilderFactoryBuilderProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.List;
import org.jboss.as.clustering.controller.IdentityLegacyCapabilityServiceConfigurator;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.msc.service.ServiceName;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.server.service.IdentityCacheServiceConfiguratorProvider;
import org.wildfly.clustering.service.ServiceConfigurator;
import org.wildfly.clustering.singleton.SingletonServiceBuilderFactory;
import org.wildfly.clustering.singleton.service.SingletonCacheRequirement;
/**
* @author Paul Ferraro
*/
@Deprecated
@MetaInfServices(IdentityCacheServiceConfiguratorProvider.class)
public class IdentitySingletonServiceBuilderFactoryBuilderProvider implements IdentityCacheServiceConfiguratorProvider {
@Override
public Iterable<ServiceConfigurator> getServiceConfigurators(CapabilityServiceSupport support, String containerName, String cacheName, String targetCacheName) {
ServiceName name = SingletonCacheRequirement.SINGLETON_SERVICE_BUILDER_FACTORY.getServiceName(support, containerName, cacheName);
return List.of(new IdentityLegacyCapabilityServiceConfigurator<>(name, SingletonServiceBuilderFactory.class, SingletonCacheRequirement.SINGLETON_SERVICE_BUILDER_FACTORY, containerName, targetCacheName).configure(support));
}
@Override
public String toString() {
return this.getClass().getName();
}
}
| 2,506
| 45.425926
| 230
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/Lifecycle.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
/**
* Encapsulates behavior associated with a lifecycle sensitive object.
* @author Paul Ferraro
*/
public interface Lifecycle {
/**
* Start this object.
*/
void start();
/**
* Stop this object.
*/
void stop();
}
| 1,327
| 32.2
| 70
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/IdentitySingletonServiceConfiguratorFactoryServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.List;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.msc.service.ServiceName;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.server.service.IdentityCacheServiceConfiguratorProvider;
import org.wildfly.clustering.service.IdentityServiceConfigurator;
import org.wildfly.clustering.service.ServiceConfigurator;
import org.wildfly.clustering.singleton.service.SingletonCacheRequirement;
/**
* @author Paul Ferraro
*/
@MetaInfServices(IdentityCacheServiceConfiguratorProvider.class)
public class IdentitySingletonServiceConfiguratorFactoryServiceConfiguratorProvider implements IdentityCacheServiceConfiguratorProvider {
@Override
public Iterable<ServiceConfigurator> getServiceConfigurators(CapabilityServiceSupport support, String containerName, String cacheName, String targetCacheName) {
ServiceName name = SingletonCacheRequirement.SINGLETON_SERVICE_CONFIGURATOR_FACTORY.getServiceName(support, containerName, cacheName);
ServiceName targetName = SingletonCacheRequirement.SINGLETON_SERVICE_CONFIGURATOR_FACTORY.getServiceName(support, containerName, targetCacheName);
ServiceConfigurator configurator = new IdentityServiceConfigurator<>(name, targetName);
return List.of(configurator);
}
}
| 2,388
| 47.755102
| 164
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/SingletonSerializationContextInitializer.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2020, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.infinispan.protostream.SerializationContextInitializer;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.marshalling.protostream.CompositeSerializationContextInitializer;
/**
* {@link org.infinispan.protostream.SerializationContextInitializer} for this package.
* @author Paul Ferraro
*/
@MetaInfServices(SerializationContextInitializer.class)
public class SingletonSerializationContextInitializer extends CompositeSerializationContextInitializer {
public SingletonSerializationContextInitializer() {
super(SingletonSerializationContextInitializerProvider.class);
}
}
| 1,691
| 41.3
| 104
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/ServiceMarshallerProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2021, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceNotFoundException;
import org.jboss.msc.service.StartException;
import org.wildfly.clustering.marshalling.protostream.ExceptionMarshaller;
import org.wildfly.clustering.marshalling.protostream.FunctionalScalarMarshaller;
import org.wildfly.clustering.marshalling.protostream.ProtoStreamMarshaller;
import org.wildfly.clustering.marshalling.protostream.ProtoStreamMarshallerProvider;
import org.wildfly.clustering.marshalling.protostream.Scalar;
import org.wildfly.common.function.Functions;
/**
* Provider of marshallers for the org.jboss.msc.service package.
* @author Paul Ferraro
*/
public enum ServiceMarshallerProvider implements ProtoStreamMarshallerProvider {
SERVICE_NAME(new FunctionalScalarMarshaller<>(Scalar.STRING.cast(String.class), Functions.constantSupplier(ServiceName.JBOSS), ServiceName::getCanonicalName, ServiceName::parse)),
SERVICE_NOT_FOUND_EXCEPTION(new ExceptionMarshaller<>(ServiceNotFoundException.class)),
START_EXCEPTION(new ExceptionMarshaller<>(StartException.class)),
;
private final ProtoStreamMarshaller<?> marshaller;
ServiceMarshallerProvider(ProtoStreamMarshaller<?> marshaller) {
this.marshaller = marshaller;
}
@Override
public ProtoStreamMarshaller<?> getMarshaller() {
return this.marshaller;
}
}
| 2,453
| 43.618182
| 183
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/SingletonServiceContext.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.wildfly.clustering.service.ServiceNameProvider;
import org.wildfly.clustering.singleton.SingletonElectionListener;
/**
* @author Paul Ferraro
*/
public interface SingletonServiceContext extends ServiceNameProvider {
SingletonElectionListener getElectionListener();
}
| 1,359
| 39
| 70
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/CacheSingletonServiceConfiguratorFactoryServiceConfigurator.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2014, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.function.Consumer;
import org.jboss.as.clustering.controller.CapabilityServiceConfigurator;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.msc.Service;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.wildfly.clustering.server.service.ClusteringCacheRequirement;
import org.wildfly.clustering.server.service.ClusteringRequirement;
import org.wildfly.clustering.service.ServiceConfigurator;
import org.wildfly.clustering.service.SimpleServiceNameProvider;
import org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory;
/**
* Configures a service providing a distributed {@link org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory}.
* @author Paul Ferraro
*/
public class CacheSingletonServiceConfiguratorFactoryServiceConfigurator extends SimpleServiceNameProvider implements CapabilityServiceConfigurator, DistributedSingletonServiceConfiguratorFactoryContext {
private final String containerName;
private final String cacheName;
private volatile ServiceName registryServiceName;
private volatile ServiceName dispatcherFactoryServiceName;
public CacheSingletonServiceConfiguratorFactoryServiceConfigurator(ServiceName name, String containerName, String cacheName) {
super(name);
this.containerName = containerName;
this.cacheName = cacheName;
}
@Override
public ServiceConfigurator configure(CapabilityServiceSupport support) {
this.registryServiceName = ClusteringCacheRequirement.SERVICE_PROVIDER_REGISTRY.getServiceName(support, this.containerName, this.cacheName);
this.dispatcherFactoryServiceName = ClusteringRequirement.COMMAND_DISPATCHER_FACTORY.getServiceName(support, this.containerName);
return this;
}
@Override
public ServiceBuilder<?> build(ServiceTarget target) {
ServiceBuilder<?> builder = target.addService(this.getServiceName());
Consumer<SingletonServiceConfiguratorFactory> factory = builder.provides(this.getServiceName());
@SuppressWarnings("deprecation")
Service service = Service.newInstance(factory, new DistributedSingletonServiceBuilderFactory(this));
return builder.setInstance(service);
}
@Override
public ServiceName getServiceProviderRegistryServiceName() {
return this.registryServiceName;
}
@Override
public ServiceName getCommandDispatcherFactoryServiceName() {
return this.dispatcherFactoryServiceName;
}
}
| 3,699
| 43.578313
| 204
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/CacheSingletonServiceConfiguratorFactoryServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2014, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.server.service.DistributedCacheServiceConfiguratorProvider;
/**
* Provides the requisite service configurators for installing a service providing a distributed {@link org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory}.
* @author Paul Ferraro
*/
@MetaInfServices(DistributedCacheServiceConfiguratorProvider.class)
public class CacheSingletonServiceConfiguratorFactoryServiceConfiguratorProvider extends SingletonServiceConfiguratorFactoryServiceConfiguratorProvider implements DistributedCacheServiceConfiguratorProvider {
public CacheSingletonServiceConfiguratorFactoryServiceConfiguratorProvider() {
super(CacheSingletonServiceConfiguratorFactoryServiceConfigurator::new);
}
}
| 1,865
| 48.105263
| 208
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/DeferredInjector.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.function.Consumer;
/**
* An injector whose source can be defined after service installation, but before the service is started.
* @author Paul Ferraro
*/
public class DeferredInjector<T> implements Consumer<T> {
private volatile Consumer<? super T> consumer;
@Override
public void accept(T value) {
this.consumer.accept(value);
}
void setConsumer(Consumer<? super T> consumer) {
this.consumer = consumer;
}
}
| 1,547
| 34.181818
| 105
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalSingletonService.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.Collections;
import java.util.Set;
import java.util.function.Supplier;
import org.jboss.msc.Service;
import org.jboss.msc.service.StartContext;
import org.jboss.msc.service.StartException;
import org.jboss.msc.service.StopContext;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.group.Node;
import org.wildfly.clustering.singleton.SingletonElectionListener;
import org.wildfly.clustering.singleton.service.SingletonService;
/**
* Local {@link SingletonService} implementation created using JBoss MSC 1.4.x service installation.
* @author Paul Ferraro
*/
public class LocalSingletonService implements SingletonService {
private final Service service;
private final Supplier<Group> group;
private final SingletonElectionListener listener;
public LocalSingletonService(Service service, LocalSingletonServiceContext context) {
this.service = service;
this.group = context.getGroup();
this.listener = context.getElectionListener();
}
@Override
public void start(StartContext context) throws StartException {
this.service.start(context);
Node localMember = this.group.get().getLocalMember();
try {
this.listener.elected(Collections.singletonList(localMember), localMember);
} catch (Throwable e) {
SingletonLogger.ROOT_LOGGER.warn(e.getLocalizedMessage(), e);
}
}
@Override
public void stop(StopContext context) {
this.service.stop(context);
}
@Override
public boolean isPrimary() {
// A local singleton is always primary
return true;
}
@Override
public Node getPrimaryProvider() {
return this.group.get().getLocalMember();
}
@Override
public Set<Node> getProviders() {
return Collections.singleton(this.group.get().getLocalMember());
}
}
| 2,969
| 33.534884
| 100
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/DistributedSingletonServiceConfiguratorFactoryContext.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.jboss.msc.service.ServiceName;
/**
* @author Paul Ferraro
*/
public interface DistributedSingletonServiceConfiguratorFactoryContext {
ServiceName getServiceProviderRegistryServiceName();
ServiceName getCommandDispatcherFactoryServiceName();
}
| 1,339
| 38.411765
| 72
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/SingletonServiceConfiguratorFactoryServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import java.util.List;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.server.service.CacheCapabilityServiceConfiguratorFactory;
import org.wildfly.clustering.server.service.CacheServiceConfiguratorProvider;
import org.wildfly.clustering.service.IdentityServiceConfigurator;
import org.wildfly.clustering.service.ServiceConfigurator;
import org.wildfly.clustering.singleton.service.SingletonCacheRequirement;
import org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory;
/**
* @author Paul Ferraro
*/
public class SingletonServiceConfiguratorFactoryServiceConfiguratorProvider implements CacheServiceConfiguratorProvider {
private final CacheCapabilityServiceConfiguratorFactory<SingletonServiceConfiguratorFactory> factory;
protected SingletonServiceConfiguratorFactoryServiceConfiguratorProvider(CacheCapabilityServiceConfiguratorFactory<SingletonServiceConfiguratorFactory> factory) {
this.factory = factory;
}
@Override
public Iterable<ServiceConfigurator> getServiceConfigurators(CapabilityServiceSupport support, String containerName, String cacheName) {
ServiceName name = SingletonCacheRequirement.SINGLETON_SERVICE_CONFIGURATOR_FACTORY.getServiceName(support, containerName, cacheName);
ServiceConfigurator configurator = this.factory.createServiceConfigurator(name, containerName, cacheName).configure(support);
@SuppressWarnings("removal")
ServiceName legacyName = SingletonCacheRequirement.SINGLETON_SERVICE_BUILDER_FACTORY.getServiceName(support, containerName, cacheName);
ServiceConfigurator legacyConfigurator = new IdentityServiceConfigurator<>(legacyName, name);
return List.of(configurator, legacyConfigurator);
}
}
| 2,911
| 50.087719
| 166
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/DistributedSingletonServiceConfiguratorFactory.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.provider.ServiceProviderRegistry;
import org.wildfly.clustering.server.dispatcher.CommandDispatcherFactory;
import org.wildfly.clustering.service.ServiceSupplierDependency;
import org.wildfly.clustering.service.SupplierDependency;
import org.wildfly.clustering.singleton.service.SingletonServiceConfigurator;
import org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory;
/**
* Factory for creating distributed {@link SingletonServiceConfigurator} instances.
* @author Paul Ferraro
*/
public class DistributedSingletonServiceConfiguratorFactory implements SingletonServiceConfiguratorFactory, DistributedSingletonServiceConfiguratorContext {
private final DistributedSingletonServiceConfiguratorFactoryContext context;
public DistributedSingletonServiceConfiguratorFactory(DistributedSingletonServiceConfiguratorFactoryContext context) {
this.context = context;
}
@Override
public SingletonServiceConfigurator createSingletonServiceConfigurator(ServiceName name) {
return new DistributedSingletonServiceConfigurator(name, this);
}
@Override
public SupplierDependency<ServiceProviderRegistry<ServiceName>> getServiceProviderRegistryDependency() {
return new ServiceSupplierDependency<>(this.context.getServiceProviderRegistryServiceName());
}
@Override
public SupplierDependency<CommandDispatcherFactory> getCommandDispatcherFactoryDependency() {
return new ServiceSupplierDependency<>(this.context.getCommandDispatcherFactoryServiceName());
}
}
| 2,702
| 44.05
| 156
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalSingletonServiceBuilderFactory.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2014, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.jboss.as.clustering.msc.InjectedValueDependency;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.service.SupplierDependency;
import org.wildfly.clustering.singleton.SingletonServiceBuilder;
import org.wildfly.clustering.singleton.SingletonServiceBuilderFactory;
/**
* Factory for creating local {@link SingletonServiceBuilder} instances.
* @author Paul Ferraro
*/
@SuppressWarnings({ "removal", "deprecation" })
public class LocalSingletonServiceBuilderFactory extends LocalSingletonServiceConfiguratorFactory implements SingletonServiceBuilderFactory {
private final LegacyLocalSingletonServiceConfiguratorContext context;
public LocalSingletonServiceBuilderFactory(LocalSingletonServiceConfiguratorFactoryContext context) {
super(context);
this.context = new LegacyLocalSingletonServiceConfiguratorContext(context);
}
@Override
public <T> SingletonServiceBuilder<T> createSingletonServiceBuilder(ServiceName name, Service<T> service) {
return new LocalSingletonServiceBuilder<>(name, service, this.context);
}
@Override
public <T> SingletonServiceBuilder<T> createSingletonServiceBuilder(ServiceName name, Service<T> primaryService, Service<T> backupService) {
return this.createSingletonServiceBuilder(name, primaryService);
}
private class LegacyLocalSingletonServiceConfiguratorContext implements LocalSingletonServiceConfiguratorContext {
private final LocalSingletonServiceConfiguratorFactoryContext context;
LegacyLocalSingletonServiceConfiguratorContext(LocalSingletonServiceConfiguratorFactoryContext context) {
this.context = context;
}
@Override
public SupplierDependency<Group> getGroupDependency() {
return new InjectedValueDependency<>(this.context.getGroupServiceName(), Group.class);
}
}
}
| 3,055
| 43.289855
| 144
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalSingletonServiceConfiguratorFactoryContext.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.jboss.msc.service.ServiceName;
/**
* @author Paul Ferraro
*/
public interface LocalSingletonServiceConfiguratorFactoryContext {
ServiceName getGroupServiceName();
}
| 1,257
| 37.121212
| 70
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalSingletonServiceConfiguratorFactoryServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2014, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.server.service.LocalCacheServiceConfiguratorProvider;
/**
* Provides the requisite service configurators for installing a service providing a local {@link org.wildfly.clustering.singleton.service.SingletonServiceConfiguratorFactory}.
* @author Paul Ferraro
*/
@MetaInfServices(LocalCacheServiceConfiguratorProvider.class)
public class LocalSingletonServiceConfiguratorFactoryServiceConfiguratorProvider extends SingletonServiceConfiguratorFactoryServiceConfiguratorProvider implements LocalCacheServiceConfiguratorProvider {
public LocalSingletonServiceConfiguratorFactoryServiceConfiguratorProvider() {
super(LocalSingletonServiceConfiguratorFactoryServiceConfigurator::new);
}
}
| 1,841
| 47.473684
| 202
|
java
|
null |
wildfly-main/clustering/singleton/server/src/main/java/org/wildfly/clustering/singleton/server/LocalSingletonServiceConfiguratorContext.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.clustering.singleton.server;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.service.SupplierDependency;
/**
* @author Paul Ferraro
*/
public interface LocalSingletonServiceConfiguratorContext {
SupplierDependency<Group> getGroupDependency();
}
| 1,322
| 37.911765
| 70
|
java
|
null |
wildfly-main/clustering/server/extension/src/test/java/org/wildfly/extension/clustering/ServiceLoaderTestCase.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering;
import java.util.ServiceLoader;
import org.jboss.logging.Logger;
import org.junit.Test;
import org.wildfly.clustering.server.service.DistributedCacheServiceConfiguratorProvider;
import org.wildfly.clustering.server.service.DistributedGroupServiceConfiguratorProvider;
import org.wildfly.clustering.server.service.IdentityCacheServiceConfiguratorProvider;
import org.wildfly.clustering.server.service.IdentityGroupServiceConfiguratorProvider;
import org.wildfly.clustering.server.service.LocalCacheServiceConfiguratorProvider;
import org.wildfly.clustering.server.service.LocalGroupServiceConfiguratorProvider;
/**
* Validates loading of services.
* @author Paul Ferraro
*/
public class ServiceLoaderTestCase {
private static final Logger LOGGER = Logger.getLogger(ServiceLoaderTestCase.class);
@Test
public void load() {
load(IdentityGroupServiceConfiguratorProvider.class);
load(IdentityCacheServiceConfiguratorProvider.class);
load(DistributedGroupServiceConfiguratorProvider.class);
load(DistributedCacheServiceConfiguratorProvider.class);
load(LocalGroupServiceConfiguratorProvider.class);
load(LocalCacheServiceConfiguratorProvider.class);
}
private static <T> void load(Class<T> targetClass) {
ServiceLoader.load(targetClass, ServiceLoaderTestCase.class.getClassLoader())
.forEach(object -> LOGGER.tracef("\t" + object.getClass().getName()));
}
}
| 2,523
| 42.517241
| 89
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/CacheJndiNameFactory.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server;
import java.util.function.BiFunction;
import org.jboss.as.clustering.naming.JndiNameFactory;
import org.jboss.as.naming.deployment.JndiName;
/**
* @author Paul Ferraro
*/
public enum CacheJndiNameFactory implements BiFunction<String, String, JndiName> {
REGISTRY_FACTORY("registry"),
SERVICE_PROVIDER_REGISTRY("providers"),
;
private final String component;
CacheJndiNameFactory(String component) {
this.component = component;
}
@Override
public JndiName apply(String containerName, String cacheName) {
return JndiNameFactory.createJndiName(JndiNameFactory.DEFAULT_JNDI_NAMESPACE, "clustering", this.component, containerName, cacheName);
}
}
| 1,774
| 35.979167
| 142
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/GroupRequirementServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server;
import java.util.List;
import java.util.function.Function;
import org.jboss.as.clustering.naming.BinderServiceConfigurator;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.as.naming.deployment.ContextNames;
import org.jboss.as.naming.deployment.JndiName;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.server.service.ClusteringRequirement;
import org.wildfly.clustering.server.service.GroupCapabilityServiceConfiguratorFactory;
import org.wildfly.clustering.server.service.GroupServiceConfiguratorProvider;
import org.wildfly.clustering.service.ServiceConfigurator;
/**
* @author Paul Ferraro
*/
public class GroupRequirementServiceConfiguratorProvider<T> implements GroupServiceConfiguratorProvider {
private final ClusteringRequirement requirement;
private final GroupCapabilityServiceConfiguratorFactory<T> factory;
private final Function<String, JndiName> jndiNameFactory;
protected GroupRequirementServiceConfiguratorProvider(ClusteringRequirement requirement, GroupCapabilityServiceConfiguratorFactory<T> factory) {
this(requirement, factory, null);
}
protected GroupRequirementServiceConfiguratorProvider(ClusteringRequirement requirement, GroupCapabilityServiceConfiguratorFactory<T> factory, Function<String, JndiName> jndiNameFactory) {
this.requirement = requirement;
this.factory = factory;
this.jndiNameFactory = jndiNameFactory;
}
@Override
public Iterable<ServiceConfigurator> getServiceConfigurators(CapabilityServiceSupport support, String group) {
ServiceName name = this.requirement.getServiceName(support, group);
ServiceConfigurator configurator = this.factory.createServiceConfigurator(name, group).configure(support);
if (this.jndiNameFactory == null) {
return List.of(configurator);
}
ContextNames.BindInfo binding = ContextNames.bindInfoFor(this.jndiNameFactory.apply(group).getAbsoluteName());
ServiceConfigurator binderConfigurator = new BinderServiceConfigurator(binding, configurator.getServiceName()).configure(support);
return List.of(configurator, binderConfigurator);
}
@Override
public String toString() {
return this.getClass().getName();
}
}
| 3,383
| 44.72973
| 192
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/IdentityCacheRequirementServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server;
import java.util.List;
import java.util.function.BiFunction;
import org.jboss.as.clustering.naming.BinderServiceConfigurator;
import org.jboss.as.clustering.naming.JndiNameFactory;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.as.naming.deployment.ContextNames;
import org.jboss.as.naming.deployment.JndiName;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.server.service.ClusteringCacheRequirement;
import org.wildfly.clustering.server.service.IdentityCacheServiceConfiguratorProvider;
import org.wildfly.clustering.service.IdentityServiceConfigurator;
import org.wildfly.clustering.service.ServiceConfigurator;
/**
* @author Paul Ferraro
*/
public class IdentityCacheRequirementServiceConfiguratorProvider implements IdentityCacheServiceConfiguratorProvider {
private final ClusteringCacheRequirement requirement;
private final BiFunction<String, String, JndiName> jndiNameFactory;
protected IdentityCacheRequirementServiceConfiguratorProvider(ClusteringCacheRequirement requirement) {
this(requirement, null);
}
protected IdentityCacheRequirementServiceConfiguratorProvider(ClusteringCacheRequirement requirement, BiFunction<String, String, JndiName> jndiNameFactory) {
this.requirement = requirement;
this.jndiNameFactory = jndiNameFactory;
}
@Override
public Iterable<ServiceConfigurator> getServiceConfigurators(CapabilityServiceSupport support, String containerName, String cacheName, String targetCacheName) {
ServiceName name = this.requirement.getServiceName(support, containerName, cacheName);
ServiceName targetName = this.requirement.getServiceName(support, containerName, targetCacheName);
ServiceConfigurator configurator = new IdentityServiceConfigurator<>(name, targetName);
if ((this.jndiNameFactory == null) || JndiNameFactory.DEFAULT_LOCAL_NAME.equals(targetCacheName)) {
return List.of(configurator);
}
ContextNames.BindInfo binding = ContextNames.bindInfoFor(this.jndiNameFactory.apply(containerName, cacheName).getAbsoluteName());
ServiceConfigurator binderConfigurator = new BinderServiceConfigurator(binding, configurator.getServiceName()).configure(support);
return List.of(configurator, binderConfigurator);
}
@Override
public String toString() {
return this.getClass().getName();
}
}
| 3,515
| 46.513514
| 164
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/CacheRequirementServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server;
import java.util.List;
import java.util.function.BiFunction;
import org.jboss.as.clustering.naming.BinderServiceConfigurator;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.as.naming.deployment.ContextNames;
import org.jboss.as.naming.deployment.JndiName;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.server.service.CacheCapabilityServiceConfiguratorFactory;
import org.wildfly.clustering.server.service.CacheServiceConfiguratorProvider;
import org.wildfly.clustering.server.service.ClusteringCacheRequirement;
import org.wildfly.clustering.service.ServiceConfigurator;
/**
* @author Paul Ferraro
*/
public class CacheRequirementServiceConfiguratorProvider<T> implements CacheServiceConfiguratorProvider {
private final ClusteringCacheRequirement requirement;
private final CacheCapabilityServiceConfiguratorFactory<T> factory;
private final BiFunction<String, String, JndiName> jndiNameFactory;
protected CacheRequirementServiceConfiguratorProvider(ClusteringCacheRequirement requirement, CacheCapabilityServiceConfiguratorFactory<T> factory) {
this(requirement, factory, null);
}
protected CacheRequirementServiceConfiguratorProvider(ClusteringCacheRequirement requirement, CacheCapabilityServiceConfiguratorFactory<T> factory, BiFunction<String, String, JndiName> jndiNameFactory) {
this.requirement = requirement;
this.factory = factory;
this.jndiNameFactory = jndiNameFactory;
}
@Override
public Iterable<ServiceConfigurator> getServiceConfigurators(CapabilityServiceSupport support, String containerName, String cacheName) {
ServiceName name = this.requirement.getServiceName(support, containerName, cacheName);
ServiceConfigurator configurator = this.factory.createServiceConfigurator(name, containerName, cacheName).configure(support);
if (this.jndiNameFactory == null) {
return List.of(configurator);
}
ContextNames.BindInfo binding = ContextNames.bindInfoFor(this.jndiNameFactory.apply(containerName, cacheName).getAbsoluteName());
ServiceConfigurator binderConfigurator = new BinderServiceConfigurator(binding, configurator.getServiceName()).configure(support);
return List.of(configurator, binderConfigurator);
}
@Override
public String toString() {
return this.getClass().getName();
}
}
| 3,508
| 46.418919
| 207
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/GroupJndiNameFactory.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server;
import java.util.function.Function;
import org.jboss.as.clustering.naming.JndiNameFactory;
import org.jboss.as.naming.deployment.JndiName;
/**
* @author Paul Ferraro
*/
public enum GroupJndiNameFactory implements Function<String, JndiName> {
COMMAND_DISPATCHER_FACTORY("dispatcher"),
GROUP("group"),
;
private final String component;
GroupJndiNameFactory(String component) {
this.component = component;
}
@Override
public JndiName apply(String group) {
return JndiNameFactory.createJndiName(JndiNameFactory.DEFAULT_JNDI_NAMESPACE, "clustering", this.component, group);
}
}
| 1,705
| 34.541667
| 123
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/IdentityGroupRequirementServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server;
import java.util.List;
import java.util.function.Function;
import org.jboss.as.clustering.naming.BinderServiceConfigurator;
import org.jboss.as.clustering.naming.JndiNameFactory;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.as.naming.deployment.ContextNames;
import org.jboss.as.naming.deployment.JndiName;
import org.jboss.msc.service.ServiceName;
import org.wildfly.clustering.server.service.ClusteringRequirement;
import org.wildfly.clustering.server.service.IdentityGroupServiceConfiguratorProvider;
import org.wildfly.clustering.service.IdentityServiceConfigurator;
import org.wildfly.clustering.service.ServiceConfigurator;
/**
* @author Paul Ferraro
*/
public class IdentityGroupRequirementServiceConfiguratorProvider implements IdentityGroupServiceConfiguratorProvider {
private final ClusteringRequirement requirement;
private final Function<String, JndiName> jndiNameFactory;
protected IdentityGroupRequirementServiceConfiguratorProvider(ClusteringRequirement requirement) {
this(requirement, null);
}
protected IdentityGroupRequirementServiceConfiguratorProvider(ClusteringRequirement requirement, Function<String, JndiName> jndiNameFactory) {
this.requirement = requirement;
this.jndiNameFactory = jndiNameFactory;
}
@Override
public Iterable<ServiceConfigurator> getServiceConfigurators(CapabilityServiceSupport support, String group, String targetGroup) {
ServiceName name = this.requirement.getServiceName(support, group);
ServiceName targetName = this.requirement.getServiceName(support, targetGroup);
ServiceConfigurator configurator = new IdentityServiceConfigurator<>(name, targetName);
if ((this.jndiNameFactory == null) || JndiNameFactory.DEFAULT_LOCAL_NAME.equals(targetGroup)) {
return List.of(configurator);
}
ContextNames.BindInfo binding = ContextNames.bindInfoFor(this.jndiNameFactory.apply(group).getAbsoluteName());
ServiceConfigurator binderConfigurator = new BinderServiceConfigurator(binding, configurator.getServiceName()).configure(support);
return List.of(configurator, binderConfigurator);
}
@Override
public String toString() {
return this.getClass().getName();
}
}
| 3,382
| 44.716216
| 146
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/group/LocalGroupServiceConfigurator.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2018, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server.group;
import java.util.function.Consumer;
import java.util.function.Function;
import org.jboss.as.clustering.controller.CapabilityServiceConfigurator;
import org.jboss.as.server.ServerEnvironment;
import org.jboss.as.server.ServerEnvironmentService;
import org.jboss.msc.Service;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceController;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.server.infinispan.group.LocalGroup;
import org.wildfly.clustering.service.FunctionalService;
import org.wildfly.clustering.service.ServiceSupplierDependency;
import org.wildfly.clustering.service.SimpleServiceNameProvider;
import org.wildfly.clustering.service.SupplierDependency;
/**
* Builds a non-clustered {@link Group}.
* @author Paul Ferraro
*/
public class LocalGroupServiceConfigurator extends SimpleServiceNameProvider implements CapabilityServiceConfigurator, Function<ServerEnvironment, Group> {
private final SupplierDependency<ServerEnvironment> environment;
public LocalGroupServiceConfigurator(ServiceName name) {
super(name);
this.environment = new ServiceSupplierDependency<>(ServerEnvironmentService.SERVICE_NAME);
}
@Override
public ServiceBuilder<?> build(ServiceTarget target) {
ServiceBuilder<?> builder = target.addService(this.getServiceName());
Consumer<Group> group = this.environment.register(builder).provides(this.getServiceName());
Service service = new FunctionalService<>(group, this, this.environment);
return builder.setInstance(service).setInitialMode(ServiceController.Mode.ON_DEMAND);
}
@Override
public Group apply(ServerEnvironment environment) {
return new LocalGroup(environment.getNodeName(), org.wildfly.clustering.server.service.LocalGroupServiceConfiguratorProvider.LOCAL);
}
}
| 3,030
| 42.927536
| 155
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/group/IdentityCacheGroupServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server.group;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.server.service.ClusteringCacheRequirement;
import org.wildfly.clustering.server.service.IdentityCacheServiceConfiguratorProvider;
import org.wildfly.extension.clustering.server.IdentityCacheRequirementServiceConfiguratorProvider;
/**
* @author Paul Ferraro
*/
@MetaInfServices(IdentityCacheServiceConfiguratorProvider.class)
public class IdentityCacheGroupServiceConfiguratorProvider extends IdentityCacheRequirementServiceConfiguratorProvider {
public IdentityCacheGroupServiceConfiguratorProvider() {
super(ClusteringCacheRequirement.GROUP);
}
}
| 1,714
| 41.875
| 120
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/group/GroupServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2014, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server.group;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.server.service.ClusteringRequirement;
import org.wildfly.clustering.server.service.GroupCapabilityServiceConfiguratorFactory;
import org.wildfly.extension.clustering.server.GroupJndiNameFactory;
import org.wildfly.extension.clustering.server.GroupRequirementServiceConfiguratorProvider;
/**
* Provides the requisite builders for a {@link Group} service created from a specified factory.
* @author Paul Ferraro
*/
public class GroupServiceConfiguratorProvider extends GroupRequirementServiceConfiguratorProvider<Group> {
public GroupServiceConfiguratorProvider(GroupCapabilityServiceConfiguratorFactory<Group> factory) {
super(ClusteringRequirement.GROUP, factory, GroupJndiNameFactory.GROUP);
}
}
| 1,871
| 44.658537
| 106
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/group/IdentityGroupServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server.group;
import org.jboss.as.clustering.naming.JndiNameFactory;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.server.service.ClusteringRequirement;
import org.wildfly.extension.clustering.server.IdentityGroupRequirementServiceConfiguratorProvider;
/**
* @author Paul Ferraro
*/
@MetaInfServices(org.wildfly.clustering.server.service.IdentityGroupServiceConfiguratorProvider.class)
public class IdentityGroupServiceConfiguratorProvider extends IdentityGroupRequirementServiceConfiguratorProvider {
public IdentityGroupServiceConfiguratorProvider() {
super(ClusteringRequirement.GROUP, alias -> JndiNameFactory.createJndiName(JndiNameFactory.DEFAULT_JNDI_NAMESPACE, "clustering", "group", alias));
}
}
| 1,811
| 44.3
| 154
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/group/LocalCacheGroupServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2014, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server.group;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.server.service.LocalCacheServiceConfiguratorProvider;
/**
* Provides the requisite builders for a non-clustered cache-based {@link Group} service.
* @author Paul Ferraro
*/
@MetaInfServices({ LocalCacheServiceConfiguratorProvider.class, org.wildfly.clustering.server.service.group.LocalCacheGroupServiceConfiguratorProvider.class })
public class LocalCacheGroupServiceConfiguratorProvider extends CacheGroupServiceConfiguratorProvider implements org.wildfly.clustering.server.service.group.LocalCacheGroupServiceConfiguratorProvider {
public LocalCacheGroupServiceConfiguratorProvider() {
super((name, containerName, cacheName) -> new LocalGroupServiceConfigurator(name));
}
}
| 1,887
| 46.2
| 201
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/group/DistributedCacheGroupServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2014, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server.group;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.server.service.DistributedCacheServiceConfiguratorProvider;
/**
* Provides the requisite builders for a clustered cache-based {@link org.wildfly.clustering.group.Group} service.
* @author Paul Ferraro
*/
@MetaInfServices({ DistributedCacheServiceConfiguratorProvider.class, org.wildfly.clustering.server.service.group.DistributedCacheGroupServiceConfiguratorProvider.class })
public class DistributedCacheGroupServiceConfiguratorProvider extends CacheGroupServiceConfiguratorProvider implements org.wildfly.clustering.server.service.group.DistributedCacheGroupServiceConfiguratorProvider {
public DistributedCacheGroupServiceConfiguratorProvider() {
super(CacheGroupServiceConfigurator::new);
}
}
| 1,864
| 46.820513
| 213
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/group/CacheGroupServiceConfigurator.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server.group;
import java.util.function.Consumer;
import java.util.function.Supplier;
import org.infinispan.Cache;
import org.jboss.as.clustering.controller.CapabilityServiceConfigurator;
import org.jboss.as.clustering.function.Consumers;
import org.jboss.as.clustering.function.Functions;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.as.server.ServerEnvironment;
import org.jboss.as.server.ServerEnvironmentService;
import org.jboss.msc.Service;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceController;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.jgroups.Address;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.infinispan.service.InfinispanCacheRequirement;
import org.wildfly.clustering.server.NodeFactory;
import org.wildfly.clustering.server.infinispan.group.AutoCloseableGroup;
import org.wildfly.clustering.server.infinispan.group.CacheGroup;
import org.wildfly.clustering.server.infinispan.group.CacheGroupConfiguration;
import org.wildfly.clustering.server.infinispan.group.LocalGroup;
import org.wildfly.clustering.server.service.ClusteringRequirement;
import org.wildfly.clustering.service.AsyncServiceConfigurator;
import org.wildfly.clustering.service.CompositeDependency;
import org.wildfly.clustering.service.FunctionalService;
import org.wildfly.clustering.service.ServiceConfigurator;
import org.wildfly.clustering.service.ServiceSupplierDependency;
import org.wildfly.clustering.service.SimpleServiceNameProvider;
import org.wildfly.clustering.service.SupplierDependency;
/**
* Builds a {@link Group} service for a cache.
* @author Paul Ferraro
*/
public class CacheGroupServiceConfigurator extends SimpleServiceNameProvider implements CapabilityServiceConfigurator, CacheGroupConfiguration, Supplier<AutoCloseableGroup<?>> {
private final String containerName;
private final String cacheName;
private final SupplierDependency<ServerEnvironment> environment;
private volatile SupplierDependency<Cache<?, ?>> cache;
private volatile SupplierDependency<NodeFactory<Address>> factory;
public CacheGroupServiceConfigurator(ServiceName name, String containerName, String cacheName) {
super(name);
this.containerName = containerName;
this.cacheName = cacheName;
this.environment = new ServiceSupplierDependency<>(ServerEnvironmentService.SERVICE_NAME);
}
@Override
public AutoCloseableGroup<?> get() {
Cache<?, ?> cache = this.cache.get();
return cache.getCacheConfiguration().clustering().cacheMode().isClustered() ? new CacheGroup(this) : new LocalGroup(this.environment.get().getNodeName(), this.containerName);
}
@Override
public ServiceConfigurator configure(CapabilityServiceSupport support) {
this.cache = new ServiceSupplierDependency<>(InfinispanCacheRequirement.CACHE.getServiceName(support, this.containerName, this.cacheName));
this.factory = new ServiceSupplierDependency<>(ClusteringRequirement.GROUP.getServiceName(support, this.containerName));
return this;
}
@Override
public ServiceBuilder<?> build(ServiceTarget target) {
ServiceName name = this.getServiceName();
ServiceBuilder<?> builder = new AsyncServiceConfigurator(name).build(target);
Consumer<Group> group = new CompositeDependency(this.cache, this.factory, this.environment).register(builder).provides(name);
Service service = new FunctionalService<>(group, Functions.identity(), this, Consumers.close());
return builder.setInstance(service).setInitialMode(ServiceController.Mode.ON_DEMAND);
}
@SuppressWarnings("unchecked")
@Override
public <K, V> Cache<K, V> getCache() {
return (Cache<K, V>) this.cache.get();
}
@Override
public NodeFactory<Address> getMemberFactory() {
return this.factory.get();
}
}
| 5,047
| 45.311927
| 182
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/group/ChannelGroupServiceConfiguratorProvider.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2014, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server.group;
import org.kohsuke.MetaInfServices;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.server.service.DistributedGroupServiceConfiguratorProvider;
/**
* Provides the requisite builders for a channel-based {@link Group} service.
* @author Paul Ferraro
*/
@MetaInfServices(DistributedGroupServiceConfiguratorProvider.class)
public class ChannelGroupServiceConfiguratorProvider extends GroupServiceConfiguratorProvider implements DistributedGroupServiceConfiguratorProvider {
public ChannelGroupServiceConfiguratorProvider() {
super((registry, group) -> new ChannelGroupServiceConfigurator(registry, group));
}
}
| 1,732
| 43.435897
| 150
|
java
|
null |
wildfly-main/clustering/server/extension/src/main/java/org/wildfly/extension/clustering/server/group/ChannelGroupServiceConfigurator.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2013, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.wildfly.extension.clustering.server.group;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import org.jboss.as.clustering.controller.CapabilityServiceConfigurator;
import org.jboss.as.controller.capability.CapabilityServiceSupport;
import org.jboss.msc.Service;
import org.jboss.msc.service.ServiceBuilder;
import org.jboss.msc.service.ServiceController;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.ServiceTarget;
import org.wildfly.clustering.dispatcher.CommandDispatcherFactory;
import org.wildfly.clustering.group.Group;
import org.wildfly.clustering.server.service.ClusteringRequirement;
import org.wildfly.clustering.service.FunctionalService;
import org.wildfly.clustering.service.ServiceConfigurator;
import org.wildfly.clustering.service.ServiceSupplierDependency;
import org.wildfly.clustering.service.SimpleServiceNameProvider;
import org.wildfly.clustering.service.SupplierDependency;
/**
* Builds a channel-based {@link Group} service.
* @author Paul Ferraro
*/
public class ChannelGroupServiceConfigurator extends SimpleServiceNameProvider implements CapabilityServiceConfigurator, Supplier<Group> {
private final String group;
private volatile SupplierDependency<CommandDispatcherFactory> factory;
public ChannelGroupServiceConfigurator(ServiceName name, String group) {
super(name);
this.group = group;
}
@Override
public Group get() {
return this.factory.get().getGroup();
}
@Override
public ServiceConfigurator configure(CapabilityServiceSupport support) {
this.factory = new ServiceSupplierDependency<>(ClusteringRequirement.COMMAND_DISPATCHER_FACTORY.getServiceName(support, this.group));
return this;
}
@Override
public ServiceBuilder<?> build(ServiceTarget target) {
ServiceBuilder<?> builder = target.addService(this.getServiceName());
Consumer<Group> group = this.factory.register(builder).provides(this.getServiceName());
Service service = new FunctionalService<>(group, Function.identity(), this);
return builder.setInstance(service).setInitialMode(ServiceController.Mode.ON_DEMAND);
}
}
| 3,271
| 40.948718
| 141
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.