Example #1
0
  /**
   * Connects this channel to a group and gets a state from a specified state provider.
   *
   * <p>This method invokes {@code connect()} and then {@code getState}.
   *
   * <p>If the FLUSH protocol is in the channel's stack definition, only one flush round is executed
   * for both connecting and fetching the state rather than two flushes if we invoke {@code connect}
   * and {@code getState} in succession.
   *
   * <p>If the channel is already connected, an error message will be printed to the error log. If
   * the channel is closed a ChannelClosed exception will be thrown.
   *
   * @param cluster_name The cluster name to connect to. Cannot be null.
   * @param target The state provider. If null, the state will be fetched from the coordinator,
   *     unless this channel is the coordinator.
   * @param timeout The timeout for the state transfer.
   * @exception Exception The protocol stack cannot be started, or the JOIN failed
   * @exception IllegalStateException The channel is closed or disconnected
   * @exception StateTransferException State transfer was not successful
   */
  public synchronized void connect(
      String cluster_name, Address target, long timeout, boolean useFlushIfPresent)
      throws Exception {
    if (!_preConnect(cluster_name)) return;

    if (cluster_name == null) { // only connect if we are not a unicast channel
      state = State.CONNECTED;
      return;
    }

    boolean canFetchState = false;
    try {
      Event connect_event =
          useFlushIfPresent
              ? new Event(Event.CONNECT_WITH_STATE_TRANSFER_USE_FLUSH, cluster_name)
              : new Event(Event.CONNECT_WITH_STATE_TRANSFER, cluster_name);
      _connect(connect_event);
      state = State.CONNECTED;
      notifyChannelConnected(this);
      canFetchState = getView() != null && getView().size() > 1;

      // if I am not the only member in cluster then
      if (canFetchState) getState(target, timeout, false); // fetch state from target
    } finally {
      // stopFlush if we fetched the state or failed to connect...
      if ((flushSupported() && useFlushIfPresent) && (canFetchState || state != State.CONNECTED))
        stopFlush();
    }
  }
 /**
  * Connects this member to the cluster using the given <code>loadFactor</code>. The <code>
  * loadFactor</code> defines the (approximate) relative load that this member will receive.
  *
  * <p>A good default value is 100, which will give this member 100 nodes on the distributed hash
  * ring. Giving all members (proportionally) lower values will result in a less evenly distributed
  * hash.
  *
  * @param loadFactor The load factor for this node.
  * @throws ConnectionFailedException when an error occurs while connecting
  */
 public synchronized void connect(int loadFactor) throws ConnectionFailedException {
   this.currentLoadFactor = loadFactor;
   Assert.isTrue(loadFactor >= 0, "Load Factor must be a positive integer value.");
   Assert.isTrue(
       channel.getReceiver() == null || channel.getReceiver() == messageReceiver,
       "The given channel already has a receiver configured. "
           + "Has the channel been reused with other Connectors?");
   try {
     channel.setReceiver(messageReceiver);
     if (channel.isConnected() && !clusterName.equals(channel.getClusterName())) {
       throw new AxonConfigurationException(
           "The Channel that has been configured with this JGroupsConnector "
               + "is already connected to another cluster.");
     } else if (channel.isConnected()) {
       // we need to fetch state now that we have attached our MessageReceiver
       channel.getState(null, 10000);
     } else {
       // we need to connect. This will automatically fetch state as well.
       channel.connect(clusterName, null, 10000);
     }
     updateMembership();
   } catch (Exception e) {
     joinedCondition.markJoined(false);
     channel.disconnect();
     throw new ConnectionFailedException("Failed to connect to JGroupsConnectorFactoryBean", e);
   }
 }
  /** Execute when new member join or leave Group */
  public void viewAccepted(View v) {
    memberSize = v.size();
    if (mainFrame != null) setTitle();
    members.clear();
    members.addAll(v.getMembers());

    if (v instanceof MergeView) {
      System.out.println("** " + v);

      // This is a simple merge function, which fetches the state from the coordinator
      // on a merge and overwrites all of its own state
      if (useState && !members.isEmpty()) {
        Address coord = members.get(0);
        Address local_addr = channel.getAddress();
        if (local_addr != null && !local_addr.equals(coord)) {
          try {

            // make a copy of our state first
            Map<Point, Color> copy = null;
            if (send_own_state_on_merge) {
              synchronized (drawPanel.state) {
                copy = new LinkedHashMap<Point, Color>(drawPanel.state);
              }
            }
            System.out.println("fetching state from " + coord);
            channel.getState(coord, 5000);
            if (copy != null)
              sendOwnState(copy); // multicast my own state so everybody else has it too
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
      }
    } else System.out.println("** View=" + v);
  }
Example #4
0
 /**
  * 启动连接。
  *
  * @throws Exception
  */
 private void start() throws Exception {
   channle = new JChannel();
   channle.setReceiver(this);
   channle.connect("ChatCluster");
   channle.getState(null, 10000);
   eventloop();
   channle.close();
 }
Example #5
0
 /** Retrieves state from the target member. See {@link #getState(Address,long)} for details. */
 public void getState(Address target, long timeout, boolean useFlushIfPresent) throws Exception {
   Callable<Boolean> flusher =
       new Callable<Boolean>() {
         public Boolean call() throws Exception {
           return Util.startFlush(JChannel.this);
         }
       };
   getState(target, timeout, useFlushIfPresent ? flusher : null);
 }
Example #6
0
  /** Tests issue #2 in http://jira.jboss.com/jira/browse/JGRP-335 */
  public void testStateTransferFollowedByUnicast() throws Exception {
    JChannel a = null;
    JChannel b = null;
    try {
      a = createChannel(true, 2, "A");
      a.setReceiver(new SimpleReplier(a, true));
      a.connect("testStateTransferFollowedByUnicast");

      Address target = a.getAddress();
      Message unicast_msg = new Message(target);

      b = createChannel(a, "B");
      b.setReceiver(new SimpleReplier(b, false));
      b.connect("testStateTransferFollowedByUnicast");

      System.out.println("\n** Getting the state **");
      b.getState(null, 10000);
      // now send unicast, this might block as described in the case
      b.send(unicast_msg);
    } finally {
      Util.close(b, a);
    }
  }
  @Override
  protected void executeRuntimeStep(OperationContext context, ModelNode operation)
      throws OperationFailedException {

    // get the channel name and channel attribute
    PathAddress pathAddress = PathAddress.pathAddress(operation.require(OP_ADDR));
    String channelName = pathAddress.getElement(pathAddress.size() - 1).getValue();
    String attrName = operation.require(NAME).asString();
    ChannelMetrics metric = ChannelMetrics.getStat(attrName);

    // lookup the channel
    ServiceName channelServiceName = ChannelInstanceResource.CHANNEL_PARENT.append(channelName);
    ServiceController<?> controller =
        context.getServiceRegistry(false).getService(channelServiceName);

    // check that the service has been installed and started
    boolean started = controller != null && controller.getValue() != null;
    ModelNode result = new ModelNode();

    if (metric == null) {
      context.getFailureDescription().set(JGroupsMessages.MESSAGES.unknownMetric(attrName));
    } else if (!started) {
      // when the cache service is not available, return a null result
    } else {
      JChannel channel = (JChannel) controller.getValue();
      switch (metric) {
        case ADDRESS:
          result.set(channel.getAddressAsString());
          break;
        case ADDRESS_AS_UUID:
          result.set(channel.getAddressAsUUID());
          break;
        case DISCARD_OWN_MESSAGES:
          result.set(channel.getDiscardOwnMessages());
          break;
        case NUM_TASKS_IN_TIMER:
          result.set(channel.getNumberOfTasksInTimer());
          break;
        case NUM_TIMER_THREADS:
          result.set(channel.getTimerThreads());
          break;
        case RECEIVED_BYTES:
          result.set(channel.getReceivedBytes());
          break;
        case RECEIVED_MESSAGES:
          result.set(channel.getReceivedMessages());
          break;
        case SENT_BYTES:
          result.set(channel.getSentBytes());
          break;
        case SENT_MESSAGES:
          result.set(channel.getSentMessages());
          break;
        case STATE:
          result.set(channel.getState());
          break;
        case STATS_ENABLED:
          result.set(channel.statsEnabled());
          break;
        case VERSION:
          result.set(JChannel.getVersion());
          break;
        case VIEW:
          result.set(channel.getViewAsString());
          break;
      }
      context.getResult().set(result);
    }
    context.completeStep(OperationContext.ResultHandler.NOOP_RESULT_HANDLER);
  }
Example #8
0
 /** Retrieves state from the target member. See {@link #getState(Address,long)} for details. */
 public void getState(Address target, long timeout, boolean useFlushIfPresent) throws Exception {
   Callable<Boolean> flusher = () -> Util.startFlush(JChannel.this);
   getState(target, timeout, useFlushIfPresent ? flusher : null);
 }
Example #9
0
 public void getState(Address target, long timeout) throws Exception {
   getState(target, timeout, true);
 }
  protected void startServer() {
    final Session session =
        Session.getSessionUsingInitiativeYearTerm(
            ApplicationProperties.getProperty("initiative", "woebegon"),
            ApplicationProperties.getProperty("year", "2010"),
            ApplicationProperties.getProperty("term", "Fal"));

    boolean remote = "true".equalsIgnoreCase(ApplicationProperties.getProperty("remote", "true"));

    if (session == null) {
      sLog.error(
          "Academic session not found, use properties initiative, year, and term to set academic session.");
      System.exit(0);
    } else {
      sLog.info("Session: " + session);
    }

    iSessionId = session.getUniqueId();

    OnlineSectioningLogger.getInstance().setEnabled(false);

    if (remote) {
      try {
        iChannel =
            new JChannel(
                JGroupsUtils.getConfigurator(
                    ApplicationProperty.SolverClusterConfiguration.value()));
        iChannel.setUpHandler(new MuxUpHandler());

        iSolverServer = new DummySolverServer(iChannel);

        iChannel.connect("UniTime:rpc");
        iChannel.getState(null, 0);

        if (getServer() == null) throw new Exception(session.getLabel() + " is not available");
      } catch (Exception e) {
        sLog.error("Failed to access the solver server: " + e.getMessage(), e);
        if (iChannel != null && iChannel.isConnected()) iChannel.disconnect();
        if (iChannel != null && iChannel.isOpen()) iChannel.close();
        System.exit(0);
      }
    } else {
      iServer =
          new InMemoryServer(
              new OnlineSectioningServerContext() {
                @Override
                public boolean isWaitTillStarted() {
                  return true;
                }

                @Override
                public EmbeddedCacheManager getCacheManager() {
                  return null;
                }

                @Override
                public Long getAcademicSessionId() {
                  return session.getUniqueId();
                }

                @Override
                public LockService getLockService() {
                  return null;
                }
              });
    }
  }