Exemplo n.º 1
0
 /**
  * If this session is not connected, this method returns; otherwise this method sends a
  * LOGOUT_REQUEST to the server, and waits for this client to receive a LOGOUT_SUCCESS
  * acknowledgment or the timeout to expire, whichever comes first. If the LOGOUT_SUCCESS
  * acknowledgment is not received, then {@code AssertionFailedError} is thrown.
  */
 public void logout() {
   synchronized (lock) {
     if (connected == false) {
       return;
     }
     logoutAck = false;
   }
   MessageBuffer buf = new MessageBuffer(1);
   buf.putByte(SimpleSgsProtocol.LOGOUT_REQUEST);
   try {
     connection.sendBytes(buf.getBuffer());
   } catch (IOException e) {
     throw new RuntimeException(e);
   }
   synchronized (lock) {
     try {
       if (logoutAck == false) {
         lock.wait(WAIT_TIME);
       }
       if (logoutAck != true) {
         fail(toString() + " logout timed out");
       }
     } catch (InterruptedException e) {
       fail(toString() + " logout timed out: " + e.toString());
     } finally {
       if (!logoutAck) disconnect();
     }
   }
 }
Exemplo n.º 2
0
  /**
   * Sends a login request and if {@code waitForLogin} is {@code true} waits for the request to be
   * acknowledged, returning {@code true} if login was successful, and {@code false} if login was
   * redirected, otherwise a {@code RuntimeException} is thrown because the login operation timed
   * out before being acknowledged.
   *
   * <p>If {@code waitForLogin} is false, this method returns {@code true} if the login is known to
   * be successful (the outcome may not yet be known because the login operation is asynchronous),
   * otherwise it returns false. Invoke {@code waitForLogin} to wait for an expected successful
   * login.
   */
  public boolean login(boolean waitForLogin) {
    synchronized (lock) {
      if (connected == false) {
        throw new RuntimeException(toString() + " not connected");
      }
    }
    String password = "******";

    MessageBuffer buf =
        new MessageBuffer(2 + MessageBuffer.getSize(name) + MessageBuffer.getSize(password));
    buf.putByte(SimpleSgsProtocol.LOGIN_REQUEST)
        .putByte(protocolVersion)
        .putString(name)
        .putString(password);
    loginAck = false;
    try {
      connection.sendBytes(buf.getBuffer());
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    if (waitForLogin) {
      if (waitForLogin()) {
        return true;
      } else if (isLoginRedirected()) {
        int port = redirectPort;
        disconnect();
        connect(port);
        return login();
      }
    }
    synchronized (lock) {
      return loginSuccess;
    }
  }
Exemplo n.º 3
0
    /** {@inheritDoc} */
    public void bytesReceived(Connection conn, byte[] buffer) {
      if (connection != conn) {
        System.err.println(
            toString()
                + "AbstractDummyClient.Listener.bytesReceived:"
                + " wrong handle, got:"
                + conn
                + ", expected:"
                + connection);
        return;
      }

      MessageBuffer buf = new MessageBuffer(buffer);
      byte opcode = buf.getByte();

      handleOpCode(opcode, buf);
    }
Exemplo n.º 4
0
    /**
     * {@inheritDoc}
     *
     * <p>Adds the specified {@code sessionId} to the per-channel cache for the given channel's
     * local member sessions, and sends a CHANNEL_JOIN protocol message to the session with the
     * corresponding {@code sessionId}.
     */
    public void join(String name, byte[] channelId, byte[] sessionId) {
      callStarted();
      try {
        if (logger.isLoggable(Level.FINEST)) {
          logger.log(
              Level.FINEST,
              "join channelId:{0} sessionId:{1}",
              HexDumper.toHexString(channelId),
              HexDumper.toHexString(sessionId));
        }

        // Update local channel membership cache.
        BigInteger channelRefId = new BigInteger(1, channelId);
        Set<BigInteger> localMembers = localChannelMembersMap.get(channelRefId);
        if (localMembers == null) {
          Set<BigInteger> newLocalMembers = Collections.synchronizedSet(new HashSet<BigInteger>());
          localMembers = localChannelMembersMap.putIfAbsent(channelRefId, newLocalMembers);
          if (localMembers == null) {
            localMembers = newLocalMembers;
          }
        }
        BigInteger sessionRefId = new BigInteger(1, sessionId);
        localMembers.add(sessionRefId);

        // Update per-session channel set cache.
        Set<BigInteger> channelSet = localPerSessionChannelsMap.get(sessionRefId);
        if (channelSet == null) {
          Set<BigInteger> newChannelSet = Collections.synchronizedSet(new HashSet<BigInteger>());
          channelSet = localPerSessionChannelsMap.putIfAbsent(sessionRefId, newChannelSet);
          if (channelSet == null) {
            channelSet = newChannelSet;
          }
        }
        channelSet.add(channelRefId);

        // Send CHANNEL_JOIN protocol message.
        MessageBuffer msg = new MessageBuffer(1 + MessageBuffer.getSize(name) + channelId.length);
        msg.putByte(SimpleSgsProtocol.CHANNEL_JOIN).putString(name).putBytes(channelId);
        sessionService.sendProtocolMessageNonTransactional(
            sessionRefId, ByteBuffer.wrap(msg.getBuffer()).asReadOnlyBuffer(), Delivery.RELIABLE);

      } finally {
        callFinished();
      }
    }
Exemplo n.º 5
0
  /**
   * Gives a subclass a chance to handle an {@code opcode}. This implementation handles login,
   * redirection, relocation, and logout but does not handle session or channel messages.
   */
  protected void handleOpCode(byte opcode, MessageBuffer buf) {

    switch (opcode) {
      case SimpleSgsProtocol.LOGIN_SUCCESS:
        reconnectKey = buf.getBytes(buf.limit() - buf.position());
        newReconnectKey(reconnectKey);
        synchronized (lock) {
          loginAck = true;
          loginSuccess = true;
          System.err.println("login succeeded: " + name);
          lock.notifyAll();
        }
        sendMessage(new byte[0], true);
        break;

      case SimpleSgsProtocol.LOGIN_FAILURE:
        String failureReason = buf.getString();
        synchronized (lock) {
          loginAck = true;
          loginSuccess = false;
          System.err.println("login failed: " + name + ", reason:" + failureReason);
          lock.notifyAll();
        }
        break;

      case SimpleSgsProtocol.LOGIN_REDIRECT:
        redirectHost = buf.getString();
        redirectPort = buf.getInt();
        synchronized (lock) {
          loginAck = true;
          loginRedirect = true;
          System.err.println(
              "login redirected: " + name + ", host:" + redirectHost + ", port:" + redirectPort);
          lock.notifyAll();
        }
        break;

      case SimpleSgsProtocol.SUSPEND_MESSAGES:
        checkRelocateProtocolVersion();
        synchronized (lock) {
          if (suspendMessages) {
            break;
          }
          suspendMessages = true;
          if (waitForSuspendMessages) {
            waitForSuspendMessages = false;
            lock.notifyAll();
          } else {
            sendSuspendMessagesComplete();
          }
        }
        break;

      case SimpleSgsProtocol.RELOCATE_NOTIFICATION:
        checkRelocateProtocolVersion();
        relocateHost = buf.getString();
        relocatePort = buf.getInt();
        relocateKey = buf.getBytes(buf.limit() - buf.position());
        synchronized (lock) {
          relocateSession = true;
          System.err.println(
              "session to relocate: "
                  + name
                  + ", host:"
                  + relocateHost
                  + ", port:"
                  + relocatePort
                  + ", key:"
                  + HexDumper.toHexString(relocateKey));
          lock.notifyAll();
        }
        break;

      case SimpleSgsProtocol.RELOCATE_SUCCESS:
        checkRelocateProtocolVersion();
        reconnectKey = buf.getBytes(buf.limit() - buf.position());
        newReconnectKey(reconnectKey);
        synchronized (lock) {
          relocateAck = true;
          relocateSuccess = true;
          System.err.println("relocate succeeded: " + name);
          lock.notifyAll();
        }
        sendMessage(new byte[0], true);
        break;

      case SimpleSgsProtocol.RELOCATE_FAILURE:
        checkRelocateProtocolVersion();
        String relocateFailureReason = buf.getString();
        synchronized (lock) {
          relocateAck = true;
          relocateSuccess = false;
          System.err.println("relocate failed: " + name + ", reason:" + relocateFailureReason);
          lock.notifyAll();
        }
        break;

      case SimpleSgsProtocol.LOGOUT_SUCCESS:
        synchronized (lock) {
          logoutAck = true;
          System.err.println("logout succeeded: " + name);
          lock.notifyAll();
        }
        break;

      default:
        System.err.println(
            "WARNING: [" + name + "] dropping unknown op code: " + String.format("%02x", opcode));
        break;
    }
  }
Exemplo n.º 6
0
    /**
     * {@inheritDoc}
     *
     * <p>Reads the local membership list for the specified {@code channelId}, and updates the local
     * membership cache for that channel. If any join or leave notifications were missed, then send
     * the appropriate CHANNEL_JOIN or CHANNEL_LEAVE protocol message to the effected session(s).
     */
    public void refresh(String name, byte[] channelId) {
      callStarted();
      if (logger.isLoggable(Level.FINE)) {
        logger.log(Level.FINE, "refreshing channelId:{0}", HexDumper.toHexString(channelId));
      }
      try {
        BigInteger channelRefId = new BigInteger(1, channelId);
        GetLocalMembersTask getMembersTask = new GetLocalMembersTask(channelRefId);
        try {
          transactionScheduler.runTask(getMembersTask, taskOwner);
        } catch (Exception e) {
          // FIXME: what is the right thing to do here?
          logger.logThrow(
              Level.WARNING,
              e,
              "obtaining members of channel:{0} throws",
              HexDumper.toHexString(channelId));
        }
        Set<BigInteger> newLocalMembers =
            Collections.synchronizedSet(getMembersTask.getLocalMembers());
        if (logger.isLoggable(Level.FINEST)) {
          logger.log(
              Level.FINEST, "newLocalMembers for channel:{0}", HexDumper.toHexString(channelId));
          for (BigInteger sessionRefId : newLocalMembers) {
            logger.log(
                Level.FINEST, "member:{0}", HexDumper.toHexString(sessionRefId.toByteArray()));
          }
        }

        /*
         * Determine which join and leave events were missed and
         * send protocol messages to clients accordingly.
         */
        Set<BigInteger> oldLocalMembers = localChannelMembersMap.put(channelRefId, newLocalMembers);
        Set<BigInteger> joiners = null;
        Set<BigInteger> leavers = null;
        if (oldLocalMembers == null) {
          joiners = newLocalMembers;
        } else {
          for (BigInteger sessionRefId : newLocalMembers) {
            if (oldLocalMembers.contains(sessionRefId)) {
              oldLocalMembers.remove(sessionRefId);
            } else {
              if (joiners == null) {
                joiners = new HashSet<BigInteger>();
              }
              joiners.add(sessionRefId);
            }
          }
          if (!oldLocalMembers.isEmpty()) {
            leavers = oldLocalMembers;
          }
        }
        if (joiners != null) {
          for (BigInteger sessionRefId : joiners) {
            MessageBuffer msg =
                new MessageBuffer(1 + MessageBuffer.getSize(name) + channelId.length);
            msg.putByte(SimpleSgsProtocol.CHANNEL_JOIN).putString(name).putBytes(channelId);
            sessionService.sendProtocolMessageNonTransactional(
                sessionRefId,
                ByteBuffer.wrap(msg.getBuffer()).asReadOnlyBuffer(),
                Delivery.RELIABLE);
          }
        }
        if (leavers != null) {
          for (BigInteger sessionRefId : leavers) {
            ByteBuffer msg = ByteBuffer.allocate(1 + channelId.length);
            msg.put(SimpleSgsProtocol.CHANNEL_LEAVE).put(channelId).flip();
            sessionService.sendProtocolMessageNonTransactional(
                sessionRefId, msg.asReadOnlyBuffer(), Delivery.RELIABLE);
          }
        }

      } finally {
        callFinished();
      }
    }