Ejemplo n.º 1
0
  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;
  }
Ejemplo n.º 2
0
  /**
   * {@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;
  }
Ejemplo n.º 3
0
  @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;
  }