private static ProtocolStackConfigurator load(String resource) throws IllegalStateException {
URL url = find(resource, JGroupsExtension.class.getClassLoader());
ROOT_LOGGER.debugf("Loading JGroups protocol defaults from %s", url.toString());
try {
return XmlConfigurator.getInstance(url);
} catch (IOException e) {
throw new IllegalArgumentException(JGroupsLogger.ROOT_LOGGER.parserFailure(url));
}
}
private static URL find(String resource, ClassLoader... loaders) {
for (ClassLoader loader : loaders) {
if (loader != null) {
URL url = loader.getResource(resource);
if (url != null) {
return url;
}
}
}
throw new IllegalArgumentException(JGroupsLogger.ROOT_LOGGER.notFound(resource));
}
@Override
public void channelConnected(Channel channel) {
// Validate view
String localName = channel.getName();
Address localAddress = channel.getAddress();
for (Address address : channel.getView()) {
String name = channel.getName(address);
if ((name != null) && name.equals(localName) && !address.equals(localAddress)) {
channel.close();
throw JGroupsLogger.ROOT_LOGGER.duplicateNodeName(
this.factory.getValue().getProtocolStackConfiguration().getEnvironment().getNodeName());
}
}
}
@Override
public Channel createChannel(final String id) throws Exception {
JGroupsLogger.ROOT_LOGGER.debugf(
"Creating channel %s from stack %s", id, this.configuration.getName());
PrivilegedExceptionAction<JChannel> action =
new PrivilegedExceptionAction<JChannel>() {
@Override
public JChannel run() throws Exception {
return new JChannel(JChannelFactory.this);
}
};
final JChannel channel = WildFlySecurityManager.doChecked(action);
ProtocolStack stack = channel.getProtocolStack();
TransportConfiguration transportConfig = this.configuration.getTransport();
SocketBinding binding = transportConfig.getSocketBinding();
if (binding != null) {
channel.setSocketFactory(new ManagedSocketFactory(binding.getSocketBindings()));
}
// Relay protocol is added to stack programmatically, not via ProtocolStackConfigurator
RelayConfiguration relayConfig = this.configuration.getRelay();
if (relayConfig != null) {
String localSite = relayConfig.getSiteName();
List<RemoteSiteConfiguration> remoteSites = this.configuration.getRelay().getRemoteSites();
List<String> sites = new ArrayList<>(remoteSites.size() + 1);
sites.add(localSite);
// Collect bridges, eliminating duplicates
Map<String, RelayConfig.BridgeConfig> bridges = new HashMap<>();
for (final RemoteSiteConfiguration remoteSite : remoteSites) {
String siteName = remoteSite.getName();
sites.add(siteName);
String clusterName = remoteSite.getClusterName();
RelayConfig.BridgeConfig bridge =
new RelayConfig.BridgeConfig(clusterName) {
@Override
public JChannel createChannel() throws Exception {
JChannel channel = (JChannel) remoteSite.getChannel();
// Don't use FORK in bridge stack
channel.getProtocolStack().removeProtocol(FORK.class);
return channel;
}
};
bridges.put(clusterName, bridge);
}
RELAY2 relay = new RELAY2().site(localSite);
for (String site : sites) {
RelayConfig.SiteConfig siteConfig = new RelayConfig.SiteConfig(site);
relay.addSite(site, siteConfig);
if (site.equals(localSite)) {
for (RelayConfig.BridgeConfig bridge : bridges.values()) {
siteConfig.addBridge(bridge);
}
}
}
Map<String, String> relayProperties = new HashMap<>(relayConfig.getProperties());
Configurator.resolveAndAssignFields(relay, relayProperties);
Configurator.resolveAndInvokePropertyMethods(relay, relayProperties);
stack.addProtocol(relay);
relay.init();
}
UnknownForkHandler unknownForkHandler =
new UnknownForkHandler() {
private final short id = ClassConfigurator.getProtocolId(RequestCorrelator.class);
@Override
public Object handleUnknownForkStack(Message message, String forkStackId) {
return this.handle(message);
}
@Override
public Object handleUnknownForkChannel(Message message, String forkChannelId) {
return this.handle(message);
}
private Object handle(Message message) {
Header header = (Header) message.getHeader(this.id);
// If this is a request expecting a response, don't leave the requester hanging - send
// an identifiable response on which it can filter
if ((header != null) && (header.type == Header.REQ) && header.rspExpected()) {
Message response =
message
.makeReply()
.setFlag(message.getFlags())
.clearFlag(Message.Flag.RSVP, Message.Flag.SCOPED);
response.putHeader(FORK.ID, message.getHeader(FORK.ID));
response.putHeader(this.id, new Header(Header.RSP, 0, header.corrId));
response.setBuffer(UNKNOWN_FORK_RESPONSE.array());
channel.down(new Event(Event.MSG, response));
}
return null;
}
};
// Add implicit FORK to the top of the stack
FORK fork = new FORK();
fork.setUnknownForkHandler(unknownForkHandler);
stack.addProtocol(fork);
fork.init();
channel.setName(this.configuration.getNodeName());
TransportConfiguration.Topology topology = this.configuration.getTransport().getTopology();
if (topology != null) {
channel.addAddressGenerator(new TopologyAddressGenerator(topology));
}
return channel;
}