コード例 #1
0
  public RedisPubSubConnection nextPubSubConnection() {
    clientsEmpty.awaitUninterruptibly();
    List<SubscribesConnectionEntry> clientsCopy =
        new ArrayList<SubscribesConnectionEntry>(clients.values());
    while (true) {
      if (clientsCopy.isEmpty()) {
        throw new RedisConnectionException("Slave subscribe-connection pool gets exhausted!");
      }

      int index = getIndex(clientsCopy);
      SubscribesConnectionEntry entry = clientsCopy.get(index);

      if (entry.isFreezed() || !entry.getSubscribeConnectionsSemaphore().tryAcquire()) {
        clientsCopy.remove(index);
      } else {
        try {
          RedisPubSubConnection conn = entry.pollFreeSubscribeConnection();
          if (conn != null) {
            return conn;
          }
          return entry.connectPubSub(config);
        } catch (RedisConnectionException e) {
          entry.getSubscribeConnectionsSemaphore().release();
          // TODO connection scoring
          log.warn("Can't connect to {}, trying next connection!", entry.getClient().getAddr());
          clientsCopy.remove(index);
        }
      }
    }
  }
コード例 #2
0
  public synchronized Collection<RedisPubSubConnection> freeze(String host, int port) {
    InetSocketAddress addr = new InetSocketAddress(host, port);
    for (SubscribesConnectionEntry connectionEntry : clients.values()) {
      if (connectionEntry.isFreezed() || !connectionEntry.getClient().getAddr().equals(addr)) {
        continue;
      }

      log.debug("{} freezed", addr);
      connectionEntry.setFreezed(true);

      // close all connections
      while (true) {
        RedisConnection connection = connectionEntry.getConnections().poll();
        if (connection == null) {
          break;
        }
        connection.closeAsync();
      }

      // close all pub/sub connections
      while (true) {
        RedisPubSubConnection connection = connectionEntry.pollFreeSubscribeConnection();
        if (connection == null) {
          break;
        }
        connection.closeAsync();
      }

      boolean allFreezed = true;
      for (SubscribesConnectionEntry entry : clients.values()) {
        if (!entry.isFreezed()) {
          allFreezed = false;
          break;
        }
      }
      if (allFreezed) {
        clientsEmpty.close();
      }

      List<RedisPubSubConnection> list =
          new ArrayList<RedisPubSubConnection>(connectionEntry.getAllSubscribeConnections());
      connectionEntry.getAllSubscribeConnections().clear();
      return list;
    }

    return Collections.emptyList();
  }
コード例 #3
0
 public int getAvailableClients() {
   int count = 0;
   for (SubscribesConnectionEntry connectionEntry : clients.values()) {
     if (!connectionEntry.isFreezed()) {
       count++;
     }
   }
   return count;
 }
コード例 #4
0
 public void returnConnection(RedisConnection connection) {
   SubscribesConnectionEntry entry = clients.get(connection.getRedisClient());
   if (entry.isFreezed()) {
     connection.closeAsync();
   } else {
     entry.getConnections().add(connection);
   }
   entry.getConnectionsSemaphore().release();
 }
コード例 #5
0
 private RedisConnection retrieveConnection(SubscribesConnectionEntry entry) {
   if (entry.isFreezed() || !entry.getConnectionsSemaphore().tryAcquire()) {
     return null;
   } else {
     RedisConnection conn = entry.getConnections().poll();
     if (conn != null) {
       return conn;
     }
     try {
       return entry.connect(config);
     } catch (RedisException e) {
       entry.getConnectionsSemaphore().release();
       // TODO connection scoring
       log.warn("Can't connect to {}, trying next connection!", entry.getClient().getAddr());
       return null;
     }
   }
 }
コード例 #6
0
 public synchronized void add(SubscribesConnectionEntry entry) {
   clients.put(entry.getClient(), entry);
   if (!entry.isFreezed()) {
     clientsEmpty.open();
   }
 }