static List<org.jgroups.conf.ProtocolConfiguration> createProtocols(
ProtocolStackConfiguration stack, boolean multicastCapable) {
List<ProtocolConfiguration> protocols = stack.getProtocols();
List<org.jgroups.conf.ProtocolConfiguration> result = new ArrayList<>(protocols.size());
TransportConfiguration transport = stack.getTransport();
for (ProtocolConfiguration protocol : protocols) {
org.jgroups.conf.ProtocolConfiguration config = createProtocol(stack, protocol);
Introspector introspector = new Introspector(config);
SocketBinding binding = protocol.getSocketBinding();
if (binding != null) {
configureBindAddress(introspector, config, binding);
configureServerSocket(introspector, config, "bind_port", binding);
configureServerSocket(introspector, config, "start_port", binding);
configureMulticastSocket(introspector, config, "mcast_addr", "mcast_port", binding);
} else if (transport.getSocketBinding() != null) {
// If no socket-binding was specified, use bind address of transport
configureBindAddress(introspector, config, transport.getSocketBinding());
}
if (!multicastCapable) {
setProperty(introspector, config, "use_mcast_xmit", String.valueOf(false));
setProperty(introspector, config, "use_mcast_xmit_req", String.valueOf(false));
}
result.add(config);
}
return result;
}
/**
* {@inheritDoc}
*
* @see org.jgroups.conf.ProtocolStackConfigurator#getProtocolStack()
*/
@Override
public List<org.jgroups.conf.ProtocolConfiguration> getProtocolStack() {
List<org.jgroups.conf.ProtocolConfiguration> stack =
new ArrayList<>(this.configuration.getProtocols().size() + 1);
TransportConfiguration transport = this.configuration.getTransport();
org.jgroups.conf.ProtocolConfiguration protocol = createProtocol(this.configuration, transport);
Map<String, String> properties = protocol.getProperties();
Introspector introspector = new Introspector(protocol);
SocketBinding binding = transport.getSocketBinding();
if (binding != null) {
configureBindAddress(introspector, protocol, binding);
configureServerSocket(introspector, protocol, "bind_port", binding);
configureMulticastSocket(introspector, protocol, "mcast_addr", "mcast_port", binding);
}
SocketBinding diagnosticsSocketBinding = transport.getDiagnosticsSocketBinding();
boolean diagnostics = (diagnosticsSocketBinding != null);
properties.put("enable_diagnostics", String.valueOf(diagnostics));
if (diagnostics) {
configureMulticastSocket(
introspector, protocol, "diagnostics_addr", "diagnostics_port", diagnosticsSocketBinding);
}
stack.add(protocol);
final Class<? extends TP> transportClass = introspector.getProtocolClass().asSubclass(TP.class);
PrivilegedExceptionAction<TP> action =
new PrivilegedExceptionAction<TP>() {
@Override
public TP run() throws InstantiationException, IllegalAccessException {
return transportClass.newInstance();
}
};
try {
stack.addAll(
createProtocols(
this.configuration, WildFlySecurityManager.doChecked(action).isMulticastCapable()));
} catch (PrivilegedActionException e) {
throw new IllegalStateException(e.getCause());
}
return stack;
}
@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;
}
