private Object authenticate(
     ClientConnection connection,
     Credentials credentials,
     ClientPrincipal principal,
     boolean firstConnection)
     throws IOException {
   final SerializationService ss = getSerializationService();
   AuthenticationRequest auth = new AuthenticationRequest(credentials, principal);
   connection.init();
   auth.setOwnerConnection(firstConnection);
   // contains remoteAddress and principal
   SerializableCollection collectionWrapper;
   try {
     collectionWrapper = (SerializableCollection) sendAndReceive(auth, connection);
   } catch (Exception e) {
     throw new RetryableIOException(e);
   }
   final Iterator<Data> iter = collectionWrapper.iterator();
   if (iter.hasNext()) {
     final Data addressData = iter.next();
     final Address address = ss.toObject(addressData);
     connection.setRemoteEndpoint(address);
     if (iter.hasNext()) {
       final Data principalData = iter.next();
       return ss.toObject(principalData);
     }
   }
   throw new AuthenticationException();
 }
 void shutdown() {
   interrupt();
   final ClientConnection c = conn;
   if (c != null) {
     c.close();
   }
 }
 @Override
 public void onConnectionClose(ClientConnection clientConnection) {
   Address endpoint = clientConnection.getRemoteEndpoint();
   if (endpoint != null) {
     connections.remove(clientConnection.getRemoteEndpoint());
     ownerConnectionFuture.closeIfAddressMatches(endpoint);
   }
 }
 private void closeIfAddressMatches(Address address) {
   final ClientConnection currentOwnerConnection = ownerConnection;
   if (currentOwnerConnection == null || !currentOwnerConnection.live()) {
     return;
   }
   if (address.equals(currentOwnerConnection.getRemoteEndpoint())) {
     close();
   }
 }
 private void process(ClientPacket packet) {
   final ClientConnection conn = packet.getClientConnection();
   try {
     handleClientMessage(packet.getClientMessage());
   } catch (Exception e) {
     logger.severe("Failed to process task: " + packet + " on responseThread :" + getName(), e);
   } finally {
     conn.decrementPacketCount();
   }
 }
 @Override
 public boolean removeEventHandler(Integer callId) {
   if (callId != null) {
     for (ClientConnection clientConnection : connections.values()) {
       if (clientConnection.deRegisterEventHandler(callId) != null) {
         return true;
       }
     }
   }
   return false;
 }
 @Override
 public void handlePacket(Packet packet) {
   final ClientConnection conn = (ClientConnection) packet.getConn();
   conn.incrementPacketCount();
   if (packet.isHeaderSet(Packet.HEADER_EVENT)) {
     final ClientListenerServiceImpl listenerService =
         (ClientListenerServiceImpl) client.getListenerService();
     listenerService.handleEventPacket(packet);
   } else {
     invocationService.handlePacket(packet);
   }
 }
 @Override
 public ClientConnection call() throws Exception {
   if (!live) {
     throw new HazelcastException("ConnectionManager is not active!!!");
   }
   SocketChannel socketChannel = null;
   try {
     socketChannel = SocketChannel.open();
     Socket socket = socketChannel.socket();
     socket.setKeepAlive(socketOptions.isKeepAlive());
     socket.setTcpNoDelay(socketOptions.isTcpNoDelay());
     socket.setReuseAddress(socketOptions.isReuseAddress());
     if (socketOptions.getLingerSeconds() > 0) {
       socket.setSoLinger(true, socketOptions.getLingerSeconds());
     }
     int bufferSize = socketOptions.getBufferSize() * KILO_BYTE;
     if (bufferSize < 0) {
       bufferSize = DEFAULT_BUFFER_SIZE_BYTE;
     }
     socket.setSendBufferSize(bufferSize);
     socket.setReceiveBufferSize(bufferSize);
     socketChannel.socket().connect(address.getInetSocketAddress(), connectionTimeout);
     SocketChannelWrapper socketChannelWrapper =
         socketChannelWrapperFactory.wrapSocketChannel(socketChannel, true);
     final ClientConnection clientConnection =
         new ClientConnection(
             ClientConnectionManagerImpl.this,
             inSelector,
             outSelector,
             connectionIdGen.incrementAndGet(),
             socketChannelWrapper,
             executionService,
             invocationService,
             client.getSerializationService());
     socketChannel.configureBlocking(true);
     if (socketInterceptor != null) {
       socketInterceptor.onConnect(socket);
     }
     authenticator.auth(clientConnection);
     socketChannel.configureBlocking(isBlock);
     socket.setSoTimeout(0);
     if (!isBlock) {
       clientConnection.getReadHandler().register();
     }
     return clientConnection;
   } catch (Exception e) {
     if (socketChannel != null) {
       socketChannel.close();
     }
     throw ExceptionUtil.rethrow(e);
   }
 }
 @Override
 public synchronized void shutdown() {
   if (!live) {
     return;
   }
   live = false;
   for (ClientConnection connection : connections.values()) {
     connection.close();
   }
   inSelector.shutdown();
   outSelector.shutdown();
   connectionLockMap.clear();
 }
 @Override
 public Object sendAndReceive(ClientRequest request, ClientConnection connection)
     throws Exception {
   final SerializationService ss = client.getSerializationService();
   connection.write(ss.toData(request));
   final Data data = connection.read();
   ClientResponse clientResponse = ss.toObject(data);
   Object response = ss.toObject(clientResponse.getResponse());
   if (response instanceof Throwable) {
     Throwable t = (Throwable) response;
     ExceptionUtil.fixRemoteStackTrace(t, Thread.currentThread().getStackTrace());
     throw new Exception(t);
   }
   return response;
 }
 public void run() {
   if (!live) {
     return;
   }
   final long now = Clock.currentTimeMillis();
   for (ClientConnection connection : connections.values()) {
     if (now - connection.lastReadTime() > heartBeatTimeout) {
       connection.heartBeatingFailed();
     }
     if (now - connection.lastReadTime() > heartBeatInterval) {
       final ClientPingRequest request = new ClientPingRequest();
       invocationService.send(request, connection);
     } else {
       connection.heartBeatingSucceed();
     }
   }
 }
 private void waitForPacketsProcessed() {
   final long begin = System.currentTimeMillis();
   int count = connection.getPacketCount();
   while (count != 0) {
     try {
       Thread.sleep(WAIT_TIME_FOR_PACKETS_TO_BE_CONSUMED);
     } catch (InterruptedException e) {
       logger.warning(e);
       break;
     }
     long elapsed = System.currentTimeMillis() - begin;
     if (elapsed > WAIT_TIME_FOR_PACKETS_TO_BE_CONSUMED_THRESHOLD) {
       logger.warning("There are packets which are not processed " + count);
       break;
     }
     count = connection.getPacketCount();
   }
 }
예제 #13
0
 boolean isConnectionHealthy(long elapsed) {
   if (elapsed >= heartBeatInterval) {
     if (sendConnection != null) {
       return sendConnection.isHeartBeating();
     } else {
       return true;
     }
   }
   return true;
 }
 public void cleanResources(
     ConstructorFunction<Object, Throwable> responseCtor, ClientConnection connection) {
   final Iterator<Map.Entry<Integer, ClientInvocation>> iter = callIdMap.entrySet().iterator();
   while (iter.hasNext()) {
     final Map.Entry<Integer, ClientInvocation> entry = iter.next();
     final ClientInvocation invocation = entry.getValue();
     if (connection.equals(invocation.getSendConnection())) {
       iter.remove();
       invocation.notifyException(responseCtor.createNew(null));
       eventHandlerMap.remove(entry.getKey());
     }
   }
   final Iterator<ClientListenerInvocation> iterator = eventHandlerMap.values().iterator();
   while (iterator.hasNext()) {
     final ClientInvocation invocation = iterator.next();
     if (connection.equals(invocation.getSendConnection())) {
       iterator.remove();
       invocation.notifyException(responseCtor.createNew(null));
     }
   }
 }
  private ClientConnection getOrConnect(Address target, Authenticator authenticator)
      throws Exception {
    if (!smartRouting) {
      target = ownerConnectionFuture.getOrWaitForCreation().getEndPoint();
    }

    Address address = addressTranslator.translate(target);

    if (address == null) {
      throw new IOException("Address is required!");
    }

    ClientConnection clientConnection = connections.get(address);
    if (clientConnection == null) {
      final Object lock = getLock(address);
      synchronized (lock) {
        clientConnection = connections.get(address);
        if (clientConnection == null) {
          final ConnectionProcessor connectionProcessor =
              new ConnectionProcessor(address, authenticator, false);
          final ICompletableFuture<ClientConnection> future =
              executionService.submitInternal(connectionProcessor);
          try {
            clientConnection = future.get(connectionTimeout, TimeUnit.MILLISECONDS);
          } catch (Exception e) {
            future.cancel(true);
            throw new RetryableIOException(e);
          }
          ClientConnection current = connections.putIfAbsent(address, clientConnection);
          if (current != null) {
            clientConnection.close();
            clientConnection = current;
          }
        }
      }
    }
    return clientConnection;
  }
  private void listenMembershipEvents() throws IOException {
    final SerializationService serializationService = clusterService.getSerializationService();
    while (!Thread.currentThread().isInterrupted()) {
      final Data clientResponseData = conn.read();
      final ClientResponse clientResponse = serializationService.toObject(clientResponseData);
      final Object eventObject = serializationService.toObject(clientResponse.getResponse());
      final ClientMembershipEvent event = (ClientMembershipEvent) eventObject;
      final MemberImpl member = (MemberImpl) event.getMember();
      boolean membersUpdated = false;
      if (event.getEventType() == MembershipEvent.MEMBER_ADDED) {
        members.add(member);
        membersUpdated = true;
      } else if (event.getEventType() == ClientMembershipEvent.MEMBER_REMOVED) {
        members.remove(member);
        membersUpdated = true;
        //                    getConnectionManager().removeConnectionPool(member.getAddress());
        // //TODO
      } else if (event.getEventType() == ClientMembershipEvent.MEMBER_ATTRIBUTE_CHANGED) {
        MemberAttributeChange memberAttributeChange = event.getMemberAttributeChange();
        Map<Address, MemberImpl> memberMap = clusterService.getMembersRef();
        if (memberMap != null) {
          for (MemberImpl target : memberMap.values()) {
            if (target.getUuid().equals(memberAttributeChange.getUuid())) {
              final MemberAttributeOperationType operationType =
                  memberAttributeChange.getOperationType();
              final String key = memberAttributeChange.getKey();
              final Object value = memberAttributeChange.getValue();
              target.updateAttribute(operationType, key, value);
              MemberAttributeEvent memberAttributeEvent =
                  new MemberAttributeEvent(client.getCluster(), target, operationType, key, value);
              clusterService.fireMemberAttributeEvent(memberAttributeEvent);
              break;
            }
          }
        }
      }

      if (membersUpdated) {
        ((ClientPartitionServiceImpl) client.getClientPartitionService()).refreshPartitions();
        updateMembersRef();
        LOGGER.info(clusterService.membersString());
        clusterService.fireMembershipEvent(
            new MembershipEvent(
                client.getCluster(),
                member,
                event.getEventType(),
                Collections.unmodifiableSet(new LinkedHashSet<Member>(members))));
      }
    }
  }
  @Override
  public void onDetectingUnresponsiveConnection(ClientConnection connection) {
    if (smartRouting) {
      // closing the owner connection if unresponsive so that it can be switched to a healthy one.
      ownerConnectionFuture.closeIfAddressMatches(connection.getEndPoint());
      // we do not close connection itself since we will continue to send heartbeat ping to this
      // connection.
      // IOUtil.closeResource(connection);
      return;
    }

    // close both owner and operation connection
    ownerConnectionFuture.close();
    IOUtil.closeResource(connection);
  }
  protected void send(ClientInvocation invocation, ClientConnection connection) throws IOException {
    if (isShutdown) {
      throw new HazelcastClientNotActiveException("Client is shut down");
    }
    registerInvocation(invocation);

    ClientMessage clientMessage = invocation.getClientMessage();
    if (!isAllowedToSendRequest(connection, invocation)
        || !writeToConnection(connection, clientMessage)) {
      final int callId = clientMessage.getCorrelationId();
      deRegisterCallId(callId);
      deRegisterEventHandler(callId);
      throw new IOException("Packet not send to " + connection.getRemoteEndpoint());
    }
    invocation.setSendConnection(connection);
  }
    @Override
    public void run() {
      try {
        int correlationId = clientMessage.getCorrelationId();
        final EventHandler eventHandler = eventHandlerMap.get(correlationId);
        if (eventHandler == null) {
          logger.warning(
              "No eventHandler for callId: " + correlationId + ", event: " + clientMessage);
          return;
        }

        eventHandler.handle(clientMessage);
      } finally {
        connection.decrementPendingPacketCount();
      }
    }
  private boolean isAllowedToSendRequest(ClientConnection connection, ClientInvocation invocation) {
    if (!connection.isHeartBeating()) {
      if (invocation.shouldBypassHeartbeatCheck()) {
        // ping and removeAllListeners should be send even though heart is not beating
        return true;
      }

      if (logger.isFinestEnabled()) {
        logger.warning(
            "Connection is not heart-beating, won't write client message -> "
                + invocation.getClientMessage());
      }
      return false;
    }
    return true;
  }
  protected void send(ClientInvocation invocation, ClientConnection connection) throws IOException {
    if (isShutdown) {
      throw new HazelcastClientNotActiveException("Client is shut down");
    }
    registerInvocation(invocation);

    ClientMessage clientMessage = invocation.getClientMessage();
    if (!isAllowedToSendRequest(connection, invocation)
        || !writeToConnection(connection, clientMessage)) {
      final int callId = clientMessage.getCorrelationId();
      ClientInvocation clientInvocation = deRegisterCallId(callId);
      deRegisterEventHandler(callId);
      if (clientInvocation != null) {
        throw new IOException("Packet not send to " + connection.getRemoteEndpoint());
      } else {
        if (logger.isFinestEnabled()) {
          logger.finest("Invocation not found to deregister for call id " + callId);
        }
      }
    }

    invocation.setSendConnection(connection);
  }
 public void removeEndpoint(Address address) {
   final ClientConnection clientConnection = connections.get(address);
   if (clientConnection != null) {
     clientConnection.close();
   }
 }
 private boolean writeToConnection(ClientConnection connection, ClientMessage clientMessage) {
   clientMessage.addFlag(ClientMessage.BEGIN_AND_END_FLAGS);
   return connection.write(clientMessage);
 }