Java CacheFactory.doSynchronousClusterTask方法代码示例

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Retuns the total number of occupants in all rooms in the server.
 *
 * @param onlyLocal true if only users connected to this JVM will be considered. Otherwise count cluster wise.
 * @return the number of existing rooms in the server.
 */
@Override
public int getNumberConnectedUsers(boolean onlyLocal) {
    int total = 0;
    for (LocalMUCUser user : users.values()) {
        if (user.isJoined()) {
            total = total + 1;
        }
    }
    // Add users from remote cluster nodes
    if (!onlyLocal) {
        Collection<Object> results =
                CacheFactory.doSynchronousClusterTask(new GetNumberConnectedUsers(), false);
        for (Object result : results) {
            if (result == null) {
                continue;
            }
            total = total + (Integer) result;
        }
    }
    return total;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void joinedCluster(byte[] nodeID) {
    Object result = CacheFactory.doSynchronousClusterTask(new GetNewMemberRoomsRequest(), nodeID);
    if (result instanceof List<?>) {
        List<RoomInfo> rooms = (List<RoomInfo>) result;
        for (RoomInfo roomInfo : rooms) {
            LocalMUCRoom remoteRoom = roomInfo.getRoom();
            MultiUserChatServiceImpl service = (MultiUserChatServiceImpl)remoteRoom.getMUCService();
            LocalMUCRoom localRoom = service.getLocalChatRoom(remoteRoom.getName());
            if (localRoom == null) {
                // Create local room with remote information
                localRoom = remoteRoom;
                service.chatRoomAdded(localRoom);
            }
            // Add remote occupants to local room
            for (OccupantAddedEvent event : roomInfo.getOccupants()) {
                event.setSendPresence(true);
                event.run();
            }
        }
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Returns the set of active conversations.
 *
 * @return the active conversations.
 */
public Collection<Conversation> getConversations() {
    if (ClusterManager.isSeniorClusterMember()) {
        List<Conversation> conversationList = new ArrayList<Conversation>(conversations.values());
        // Sort the conversations by creation date.
        Collections.sort(conversationList, new Comparator<Conversation>() {
            public int compare(Conversation c1, Conversation c2) {
                return c1.getStartDate().compareTo(c2.getStartDate());
            }
        });
        return conversationList;
    }
    else {
        // Get this info from the senior cluster member when running in a cluster
        return (Collection<Conversation>) CacheFactory.doSynchronousClusterTask(new GetConversationsTask(),
                ClusterManager.getSeniorClusterMember().toByteArray());
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Unregisters all caches for the given plugin.
 *
 * @param pluginName the name of the plugin whose caches will be unregistered.
 */
public void unregisterCaches(String pluginName) {
    List<CacheInfo> caches = pluginCaches.remove(pluginName);
    if (caches != null) {
        for (CacheInfo info : caches) {
            extraCacheMappings.remove(info.getCacheName());
            // Check if other cluster nodes have this plugin installed
            Collection<Object> answers =
                    CacheFactory.doSynchronousClusterTask(new IsPluginInstalledTask(pluginName), false);
            for (Object installed : answers) {
                if ((Boolean) installed) {
                    return;
                }
            }
            // Destroy cache if we are the last node hosting this plugin
            try {
                CacheFactory.destroyCache(info.getCacheName());
            }
            catch (Exception e) {
                Log.warn(e.getMessage(), e);
            }
        }
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Retuns the total number of occupants in all rooms in the server.
 *
 * @param onlyLocal true if only users connected to this JVM will be considered. Otherwise count cluster wise.
 * @return the number of existing rooms in the server.
 */
public int getNumberConnectedUsers(boolean onlyLocal) {
    int total = 0;
    for (LocalMUCUser user : users.values()) {
        if (user.isJoined()) {
            total = total + 1;
        }
    }
    // Add users from remote cluster nodes
    if (!onlyLocal) {
        Collection<Object> results =
                CacheFactory.doSynchronousClusterTask(new GetNumberConnectedUsers(), false);
        for (Object result : results) {
            if (result == null) {
                continue;
            }
            total = total + (Integer) result;
        }
    }
    return total;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
public void joinedCluster(byte[] nodeID) {
    @SuppressWarnings("unchecked")
    List<RoomInfo> result =
            (List<RoomInfo>) CacheFactory.doSynchronousClusterTask(new GetNewMemberRoomsRequest(), nodeID);
    if (result != null) {
        for (RoomInfo roomInfo : result) {
            LocalMUCRoom remoteRoom = roomInfo.getRoom();
            MultiUserChatServiceImpl service = (MultiUserChatServiceImpl)remoteRoom.getMUCService();
            LocalMUCRoom localRoom = service.getLocalChatRoom(remoteRoom.getName());
            if (localRoom == null) {
                // Create local room with remote information
                localRoom = remoteRoom;
                service.chatRoomAdded(localRoom);
            }
            // Add remote occupants to local room
            for (OccupantAddedEvent event : roomInfo.getOccupants()) {
                event.setSendPresence(true);
                event.run();
            }
        }
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
     * Updates the presence of the given user with the new role information. Do nothing if the given
     * jid is not present in the room.
     *
     * @param jid the full jid of the user to update his/her role.
     * @param newRole the new role for the JID.
     * @return the updated presence of the user or null if none.
     * @throws NotAllowedException If trying to change the moderator role to an owner or an admin.
     */
    private Presence changeOccupantRole(JID jid, MUCRole.Role newRole) throws NotAllowedException {
        // Try looking the role in the bare JID list
        MUCRole role = occupantsByFullJID.get(jid);
// TODO
//            if (!isPrivilegedToChangeAffiliationAndRole(senderRole.getAffiliation(), senderRole.getRole(), role.getAffiliation(), role.getRole(), newAffiliation, newRole)) {
//                throw new NotAllowedException();
//            }
        if (role != null) {
            if (role.isLocal()) {
                // Update the presence with the new role
                role.setRole(newRole);
                // Notify the other cluster nodes to update the occupant
                CacheFactory.doClusterTask(new UpdateOccupant(this, role));
                // Prepare a new presence to be sent to all the room occupants
                return role.getPresence().createCopy();
            }
            else {
                // Ask the cluster node hosting the occupant to make the changes. Note that if the change
                // is not allowed a NotAllowedException will be thrown
                Element element = (Element) CacheFactory.doSynchronousClusterTask(
                        new UpdateOccupantRequest(this, role.getNickname(), null, newRole),
                        role.getNodeID().toByteArray());
                if (element != null) {
                    // Prepare a new presence to be sent to all the room occupants
                    return new Presence(element, true);
                }
                else {
                    throw new NotAllowedException();
                }
            }
        }
        return null;
    }
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Returns the count of active conversations.
 * 
 * @return the count of active conversations.
 */
public int getConversationCount() {
	if (ClusterManager.isSeniorClusterMember()) {
		return conversations.size();
	}
	return (Integer) CacheFactory.doSynchronousClusterTask(new GetConversationCountTask(), ClusterManager.getSeniorClusterMember().toByteArray());
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
   * Updates all the presences of the given user with the new affiliation and role information. Do
   * nothing if the given jid is not present in the room. If the user has joined the room from
   * several client resources, all his/her occupants' presences will be updated.
   *
   * @param jid the bare jid of the user to update his/her role.
   * @param newAffiliation the new affiliation for the JID.
   * @param newRole the new role for the JID.
   * @return the list of updated presences of all the client resources that the client used to
   *         join the room.
   * @throws NotAllowedException If trying to change the moderator role to an owner or an admin or
   *         if trying to ban an owner or an administrator.
   */
  private List<Presence> changeOccupantAffiliation(JID jid, MUCRole.Affiliation newAffiliation, MUCRole.Role newRole)
          throws NotAllowedException {
      List<Presence> presences = new ArrayList<Presence>();
      // Get all the roles (i.e. occupants) of this user based on his/her bare JID
      JID bareJID = jid.asBareJID();
List<MUCRole> roles = occupantsByBareJID.get(bareJID);
      if (roles == null) {
          return presences;
      }
      // Collect all the updated presences of these roles
      for (MUCRole role : roles) {
          // Update the presence with the new affiliation and role
          if (role.isLocal()) {
              role.setAffiliation(newAffiliation);
              role.setRole(newRole);
              // Notify the other cluster nodes to update the occupant
              CacheFactory.doClusterTask(new UpdateOccupant(this, role));
              // Prepare a new presence to be sent to all the room occupants
              presences.add(role.getPresence().createCopy());
          }
          else {
              // Ask the cluster node hosting the occupant to make the changes. Note that if the change
              // is not allowed a NotAllowedException will be thrown
              Element element = (Element) CacheFactory.doSynchronousClusterTask(
                      new UpdateOccupantRequest(this, role.getNickname(), newAffiliation, newRole),
                      role.getNodeID().toByteArray());
              if (element != null) {
                  // Prepare a new presence to be sent to all the room occupants
                  presences.add(new Presence(element, true));
              }
              else {
                  throw new NotAllowedException();
              }
          }
      }
      // Answer all the updated presences
      return presences;
  }
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Returns the count of active conversations.
 *
 * @return the count of active conversations.
 */
public int getConversationCount() {
    if (ClusterManager.isSeniorClusterMember()) {
        return conversations.size();
    }
    return (Integer) CacheFactory.doSynchronousClusterTask(new GetConversationCountTask(),
            ClusterManager.getSeniorClusterMember().toByteArray());
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Returns a Map of HazelcastRuntimeStats.NodeInfo objects keyed by cluster Member objects.
 * A NodeInfo object is a collection of various Node stats.
 *
 * @return a Map of NodeInfo objects.
 */
public static Map<NodeID, NodeInfo> getNodeInfo() {

    // Run cluster-wide stats query
    Collection<Object> taskResult = CacheFactory.doSynchronousClusterTask(new NodeInfoTask(), true);
    Map<NodeID, NodeInfo> result = new HashMap<NodeID, NodeInfo>();
    for (Object tr : taskResult) {
        NodeInfo nodeInfo = (NodeInfo) tr;
        NodeID nodeId = NodeID.getInstance(nodeInfo.getNodeId());
        result.put(nodeId, nodeInfo);
    }
    return result;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Returns number of client sessions that are authenticated with the server. This includes
 * anonymous and non-anoymous users.
 *
 * @param onlyLocal true if only sessions connected to this JVM will be considered. Otherwise count cluster wise.
 * @return number of client sessions that are authenticated with the server.
 */
public int getUserSessionsCount(boolean onlyLocal) {
    int total = routingTable.getClientsRoutes(true).size();
    if (!onlyLocal) {
        Collection<Object> results =
                CacheFactory.doSynchronousClusterTask(new GetSessionsCountTask(true), false);
        for (Object result : results) {
            if (result == null) {
                continue;
            }
            total = total + (Integer) result;
        }
    }
    return total;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Updates the presence of the given user with the new role information. Do nothing if the given
 * jid is not present in the room.
 *
 * @param jid the full jid of the user to update his/her role.
 * @param newRole the new role for the JID.
 * @return the updated presence of the user or null if none.
 * @throws NotAllowedException If trying to change the moderator role to an owner or an admin.
 */
private Presence changeOccupantRole(JID jid, MUCRole.Role newRole) throws NotAllowedException {
    // Try looking the role in the bare JID list
    MUCRole role = occupantsByFullJID.get(jid);
    if (role != null) {
        if (role.isLocal()) {
            // Update the presence with the new role
            role.setRole(newRole);
            // Notify the othe cluster nodes to update the occupant
            CacheFactory.doClusterTask(new UpdateOccupant(this, role));
            // Prepare a new presence to be sent to all the room occupants
            return role.getPresence().createCopy();
        }
        else {
            // Ask the cluster node hosting the occupant to make the changes. Note that if the change
            // is not allowed a NotAllowedException will be thrown
            Element element = (Element) CacheFactory.doSynchronousClusterTask(
                    new UpdateOccupantRequest(this, role.getNickname(), null, newRole),
                    role.getNodeID().toByteArray());
            if (element != null) {
                // Prepare a new presence to be sent to all the room occupants
                return new Presence(element, true);
            }
            else {
                throw new NotAllowedException();
            }
        }
    }
    return null;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Returns number of client sessions that are connected to the server. Sessions that
 * are authenticated and not authenticated will be included
 *
 * @param onlyLocal true if only sessions connected to this JVM will be considered. Otherwise count cluster wise.
 * @return number of client sessions that are connected to the server.
 */
public int getConnectionsCount(boolean onlyLocal) {
    int total = connectionsCounter.get();
    if (!onlyLocal) {
        Collection<Object> results =
                CacheFactory.doSynchronousClusterTask(new GetSessionsCountTask(false), false);
        for (Object result : results) {
            if (result == null) {
                continue;
            }
            total = total + (Integer) result;
        }
    }
    return total;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
public void propertySet(String service, String property, Map<String, Object> params) {
    // Let everyone know we've had an update.
    CacheFactory.doSynchronousClusterTask(new ServiceUpdatedEvent(service), false);
}