Java CacheFactory.getLock方法代码示例

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
private void restoreCacheContent() {
    for (Map.Entry<String, Element> entry : localServerItems.entrySet()) {
        String jid = entry.getKey();
        Element element = entry.getValue();
        Lock lock = CacheFactory.getLock(jid, serverItems);
        try {
            lock.lock();
            ClusteredServerItem item = serverItems.get(jid);
            if (item == null) {
                // First time a node registers a server item for this component
                item = new ClusteredServerItem();
                item.element = element;
            }
            if (item.nodes.add(XMPPServer.getInstance().getNodeID())) {
                // Update the cache with latest info
                serverItems.put(jid, item);
            }
        }
        finally {
            lock.unlock();
        }
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Removes a disco item for a component that has been removed from the server.
 *
 * @param jid the jid of the component being removed.
 */
public void removeComponentItem(String jid) {
    if (serverItems == null) {
        // Safety check
        return;
    }
    Lock lock = CacheFactory.getLock(jid, serverItems);
    try {
        lock.lock();
        ClusteredServerItem item = serverItems.get(jid);
        if (item != null && item.nodes.remove(XMPPServer.getInstance().getNodeID())) {
            // Update the cache with latest info
            if (item.nodes.isEmpty()) {
                serverItems.remove(jid);
            }
            else {
                serverItems.put(jid, item);
            }
        }
    }
    finally {
        lock.unlock();
    }
    // Remove locally added server item
    localServerItems.remove(jid);
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Removes a feature from the information returned whenever a disco for information is
 * made against the server.
 *
 * @param namespace the namespace of the feature to be removed.
 */
public void removeServerFeature(String namespace) {
    if (localServerFeatures.remove(namespace)) {
        Lock lock = CacheFactory.getLock(namespace, serverFeatures);
        try {
            lock.lock();
            Set<NodeID> nodeIDs = serverFeatures.get(namespace);
            if (nodeIDs != null) {
                nodeIDs.remove(XMPPServer.getInstance().getNodeID());
                if (nodeIDs.isEmpty()) {
                    serverFeatures.remove(namespace);
                }
                else {
                    serverFeatures.put(namespace, nodeIDs);
                }
            }
        }
        finally {
            lock.unlock();
        }
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
public boolean removeComponentRoute(JID route) {
    String address = route.getDomain();
    boolean removed = false;
    Lock lock = CacheFactory.getLock(address, componentsCache);
    try {
        lock.lock();
        Set<NodeID> nodes = componentsCache.get(address);
        if (nodes != null) {
            removed = nodes.remove(server.getNodeID());
            if (nodes.isEmpty()) {
                componentsCache.remove(address);
            }
            else {
                componentsCache.put(address, nodes);
            }
        }
    } finally {
        lock.unlock();
    }
    localRoutingTable.removeRoute(address);
    return removed;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Deletes the {@link PEPService} belonging to the specified owner.
 * 
 * @param owner
 *            The JID of the owner of the service to be deleted.
 */
public void remove(JID owner) {
	PEPService service = null;

	final Lock lock = CacheFactory.getLock(owner, pepServices);
	try {
		lock.lock();
		service = pepServices.remove(owner.toBareJID());
	} finally {
		lock.unlock();
	}

	if (service == null) {
		return;
	}

	// Delete the user's PEP nodes from memory and the database.
	CollectionNode rootNode = service.getRootCollectionNode();
	for (final Node node : service.getNodes()) {
		if (rootNode.isChildNode(node)) {
			node.delete();
		}
	}
	rootNode.delete();
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
@Override
public boolean removeComponentRoute(JID route) {
    String address = route.getDomain();
    boolean removed = false;
    Lock lock = CacheFactory.getLock(address, componentsCache);
    try {
        lock.lock();
        Set<NodeID> nodes = componentsCache.get(address);
        if (nodes != null) {
            removed = nodes.remove(server.getNodeID());
            if (nodes.isEmpty()) {
                componentsCache.remove(address);
            }
            else {
                componentsCache.put(address, nodes);
            }
        }
    } finally {
        lock.unlock();
    }
    localRoutingTable.removeRoute(new DomainPair("", address));
    return removed;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
public void leftCluster(byte[] nodeID) {
    if (ClusterManager.isSeniorClusterMember()) {
        NodeID leftNode = NodeID.getInstance(nodeID);
        // Remove server features added by node that is gone
        for (Map.Entry<String, Set<NodeID>> entry : serverFeatures.entrySet()) {
            String namespace = entry.getKey();
            Lock lock = CacheFactory.getLock(namespace, serverFeatures);
            try {
                lock.lock();
                Set<NodeID> nodeIDs = entry.getValue();
                if (nodeIDs.remove(leftNode)) {
                    if (nodeIDs.isEmpty()) {
                        serverFeatures.remove(namespace);
                    }
                    else {
                        serverFeatures.put(namespace, nodeIDs);
                    }
                }
            }
            finally {
                lock.unlock();
            }
        }
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Adds one specific feature to the information returned whenever a disco for information is
 * made against the server.
 *
 * @param namespace the namespace identifying the new server feature.
 */
public void addServerFeature(String namespace) {
    if (localServerFeatures.add(namespace)) {
        Lock lock = CacheFactory.getLock(namespace, serverFeatures);
        try {
            lock.lock();
            Set<NodeID> nodeIDs = serverFeatures.get(namespace);
            if (nodeIDs == null) {
                nodeIDs = new HashSet<>();
            }
            nodeIDs.add(XMPPServer.getInstance().getNodeID());
            serverFeatures.put(namespace, nodeIDs);
        }
        finally {
            lock.unlock();
        }
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Returns the secret key that was randomly generated. When running inside of a cluster
 * the key will be unique to all cluster nodes.
 *
 * @return the secret key that was randomly generated.
 */
private static String getSecretkey() {
    String key = "secretKey";
    Lock lock = CacheFactory.getLock(key, secretKeyCache);
    try {
        lock.lock();
        String secret = secretKeyCache.get(key);
        if (secret == null) {
            secret = StringUtils.randomString(10);
            secretKeyCache.put(key, secret);
        }
        return secret;
    }
    finally {
        lock.unlock();
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
public void start(int initialDelayMinutes, int intervalMinutes) {
  try {
    LOGGER.trace("start : creating lock");
    lock = CacheFactory.getLock(APNS_FEEDBACK_TASK_KEY);
  } catch (Exception e) {
    LOGGER.error("start : caught exception getting lock instance");
  }
  LOGGER.info("scheduling APNSFeedbackProcessExecutionManager. initialDelay(min):{} interval(min):{}",
      initialDelayMinutes, intervalMinutes);
  scheduler.scheduleAtFixedRate(new APNSFeedbackProcessor(lock), initialDelayMinutes, intervalMinutes, TimeUnit.MINUTES);
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
protected void initializeBots() {
  final String BOT_LOCK = "BotStarterLock";
  Lock clusterLock;
  try {
    Log.trace("initializeBots : getting lock");
    clusterLock = CacheFactory.getLock(BOT_LOCK);
    BotStarter starter = new BotStarter(clusterLock);
    Executors.newSingleThreadExecutor().execute(starter);
    Log.trace("initializeBots: submitted the bot starter");
  } catch (Exception e) {
    Log.error("initializeBots : caught exception", e);
  }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
@Override
public void startWakeupExecution(WakeupConfig config) {
  try {
    LOGGER.trace("startWakeupExecution : getting lock");
    lock = CacheFactory.getLock(WAKEUP_LOCK_KEY);
  } catch (Exception e) {
    LOGGER.error("startWakeupExecution : caught exception  getting lock");
  }
  LOGGER.info("Scheduling wakeup execution with config:{}", config);
  final ScheduledFuture<?> wakeupScheduledHandler =
      scheduler.scheduleAtFixedRate(new WakeupProcessor(lock), config.getInitialDelay(), config.getPeriod(), TimeUnit.SECONDS);
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
@Override
public void startTimeoutCheck(int initialDelay, int interval) {
  try {
    LOGGER.trace("startTimeoutCheck : getting lock");
    lock = CacheFactory.getLock(TIMEOUT_TASK_LOCK_KEY);
  } catch (Exception e) {
    LOGGER.error("startTimeoutCheck : caught exception getting lock");
  }
  LOGGER.info("scheduling timeout processor");
  scheduler.scheduleAtFixedRate(new TimeoutProcessor(lock), initialDelay, interval, TimeUnit.SECONDS);
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
@Override
public void startRetryCheck(int initialDelay, int interval) {
  try {
    LOGGER.trace("startRetryCheck : creating lock");
    lock = CacheFactory.getLock(RETRY_CHECK_LOCK_KEY);
  } catch (Exception e) {
    LOGGER.error("startRetryCheck : caught exception getting lock instance");
  }
  LOGGER.info("scheduling retry check processor");
  scheduler.scheduleAtFixedRate(new RetryProcessor(lock), initialDelay, interval, TimeUnit.SECONDS);
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入方法依赖的package包/类
/**
 * Registers that a server session originated by a remote server is hosting a given hostname.
 * Notice that the remote server may be hosting several subdomains as well as virtual hosts so
 * the same IncomingServerSession may be associated with many keys. If the remote server
 * creates many sessions to this server (eg. one for each subdomain) then associate all
 * the sessions with the originating server that created all the sessions.
 *
 * @param hostname the hostname that is being served by the remote server.
 * @param session the incoming server session to the remote server.
 */
public void registerIncomingServerSession(String hostname, LocalIncomingServerSession session) {
    // Keep local track of the incoming server session connected to this JVM
    StreamID streamID = session.getStreamID();
    localSessionManager.addIncomingServerSessions(streamID, session);
    // Keep track of the nodeID hosting the incoming server session
    incomingServerSessionsCache.put(streamID, server.getNodeID().toByteArray());
    // Update list of sockets/sessions coming from the same remote hostname
    Lock lock = CacheFactory.getLock(hostname, hostnameSessionsCache);
    try {
        lock.lock();
        List<StreamID> streamIDs = hostnameSessionsCache.get(hostname);
        if (streamIDs == null) {
            streamIDs = new ArrayList<>();
        }
        streamIDs.add(streamID);
        hostnameSessionsCache.put(hostname, streamIDs);
    }
    finally {
        lock.unlock();
    }
    // Add to clustered cache
    lock = CacheFactory.getLock(streamID, validatedDomainsCache);
    try {
        lock.lock();
        Set<String> validatedDomains = validatedDomainsCache.get(streamID);
        if (validatedDomains == null) {
            validatedDomains = new HashSet<>();
        }
        boolean added = validatedDomains.add(hostname);
        if (added) {
            validatedDomainsCache.put(streamID, validatedDomains);
        }
    } finally {
        lock.unlock();
    }
}