/**
* @param nodeId Node ID.
* @return Class loader ID for node ID.
*/
GridTuple2<GridUuid, Long> getClassLoaderId(UUID nodeId) {
assert nodeId != null;
assert Thread.holdsLock(mux);
return loader().registeredClassLoaderId(nodeId);
}
/**
* Checks if node is participating in deployment.
*
* @param nodeId Node ID to check.
* @param ldrId Class loader ID.
* @return {@code True} if node is participating in deployment.
*/
boolean hasParticipant(UUID nodeId, GridUuid ldrId) {
assert nodeId != null;
assert ldrId != null;
assert Thread.holdsLock(mux);
return loader().hasRegisteredNode(nodeId, ldrId);
}
/**
* Adds new participant to deployment.
*
* @param dep Shared deployment.
* @param meta Request metadata.
* @return {@code True} if participant was added.
*/
private boolean addParticipant(SharedDeployment dep, GridDeploymentMetadata meta) {
assert dep != null;
assert meta != null;
assert Thread.holdsLock(mux);
if (!checkModeMatch(dep, meta)) return false;
if (meta.participants() != null) {
for (Map.Entry<UUID, GridTuple2<GridUuid, Long>> e : meta.participants().entrySet()) {
dep.addParticipant(e.getKey(), e.getValue().get1(), e.getValue().get2());
if (log.isDebugEnabled())
log.debug(
"Added new participant [nodeId="
+ e.getKey()
+ ", clsLdrId="
+ e.getValue().get1()
+ ", seqNum="
+ e.getValue().get2()
+ ']');
}
}
if (dep.deployMode() == CONTINUOUS || meta.participants() == null) {
if (!dep.addParticipant(meta.senderNodeId(), meta.classLoaderId(), meta.sequenceNumber())) {
U.warn(
log,
"Failed to create shared mode deployment "
+ "(requested class loader was already undeployed, did sender node leave grid?) "
+ "[clsLdrId="
+ meta.classLoaderId()
+ ", senderNodeId="
+ meta.senderNodeId()
+ ']');
return false;
}
if (log.isDebugEnabled())
log.debug(
"Added new participant [nodeId="
+ meta.senderNodeId()
+ ", clsLdrId="
+ meta.classLoaderId()
+ ", seqNum="
+ meta.sequenceNumber()
+ ']');
}
return true;
}
/**
* @param meta Request metadata.
* @return {@code True} if class loader is obsolete.
*/
private boolean isDeadClassLoader(GridDeploymentMetadata meta) {
assert Thread.holdsLock(mux);
synchronized (mux) {
if (deadClsLdrs.contains(meta.classLoaderId())) {
if (log.isDebugEnabled()) log.debug("Ignoring request for obsolete class loader: " + meta);
return true;
}
return false;
}
}
/** Sets property removed. */
void onRemoved() {
assert Thread.holdsLock(mux);
removed = true;
Collection<GridUuid> deadIds = loader().registeredClassLoaderIds();
if (log.isDebugEnabled()) log.debug("Registering dead class loader IDs: " + deadIds);
synchronized (mux) {
deadClsLdrs.addAll(deadIds);
}
}
/** @param nodeId Node ID to remove. */
void removeParticipant(UUID nodeId) {
assert nodeId != null;
assert Thread.holdsLock(mux);
GridUuid ldrId = loader().unregister(nodeId);
if (log.isDebugEnabled()) log.debug("Registering dead class loader ID: " + ldrId);
synchronized (mux) {
deadClsLdrs.add(ldrId);
}
}
/**
* @param nodeId Grid node ID.
* @param ldrId Class loader ID.
* @param seqNum Sequence number for the class loader.
* @return Whether actually added or not.
*/
boolean addParticipant(UUID nodeId, GridUuid ldrId, long seqNum) {
assert nodeId != null;
assert ldrId != null;
assert Thread.holdsLock(mux);
synchronized (mux) {
if (!deadClsLdrs.contains(ldrId)) {
loader().register(nodeId, ldrId, seqNum);
return true;
}
return false;
}
}
private <T> T doIndexTask(IndexTask<T> task, T defaultValue) {
assert Thread.holdsLock(this);
if (!isBroken) {
try {
return task.doTask();
} catch (Exception e1) {
MavenLog.LOG.warn(e1);
cleanupBrokenData();
try {
open();
} catch (MavenIndexException e2) {
MavenLog.LOG.warn(e2);
}
}
}
markAsBroken();
return defaultValue;
}
/**
* Called to record all undeployed classes..
*
* @param leftNodeId Left node ID.
*/
void recordUndeployed(@Nullable UUID leftNodeId) {
assert !Thread.holdsLock(mux);
for (Map.Entry<String, Class<?>> depCls : deployedClassMap().entrySet()) {
boolean isTask = isTask(depCls.getValue());
String msg =
(isTask ? "Task" : "Class")
+ " was undeployed in SHARED or CONTINUOUS mode: "
+ depCls.getValue();
int type = isTask ? EVT_TASK_UNDEPLOYED : EVT_CLASS_UNDEPLOYED;
if (ctx.event().isRecordable(type)) {
GridDeploymentEvent evt = new GridDeploymentEvent();
evt.nodeId(ctx.localNodeId());
evt.message(msg);
evt.type(type);
evt.alias(depCls.getKey());
ctx.event().record(evt);
}
if (log.isInfoEnabled()) log.info(msg);
}
if (isObsolete()) {
// Resource cleanup.
ctx.resource().onUndeployed(this);
ctx.cache().onUndeployed(leftNodeId, loader());
clearSerializationCaches();
}
}
/** {@inheritDoc} */
@Override
public void onDeployed(Class<?> cls) {
assert !Thread.holdsLock(mux);
boolean isTask = isTask(cls);
String msg =
(isTask ? "Task" : "Class") + " was deployed in SHARED or CONTINUOUS mode: " + cls;
int type = isTask ? EVT_TASK_DEPLOYED : EVT_CLASS_DEPLOYED;
if (ctx.event().isRecordable(type)) {
GridDeploymentEvent evt = new GridDeploymentEvent();
evt.nodeId(ctx.localNodeId());
evt.message(msg);
evt.type(type);
evt.alias(cls.getName());
ctx.event().record(evt);
}
if (log.isInfoEnabled()) log.info(msg);
}
/**
* Creates and caches new deployment.
*
* @param meta Deployment metadata.
* @param isCache Whether or not to cache.
* @return New deployment.
*/
private SharedDeployment createNewDeployment(GridDeploymentMetadata meta, boolean isCache) {
assert Thread.holdsLock(mux);
assert meta.parentLoader() == null;
GridUuid ldrId = GridUuid.randomUuid();
GridDeploymentClassLoader clsLdr;
if (meta.deploymentMode() == CONTINUOUS || meta.participants() == null) {
// Create peer class loader.
// Note that we are passing empty list for local P2P exclude, as it really
// does not make sense with shared deployment.
clsLdr =
new GridDeploymentClassLoader(
ldrId,
meta.userVersion(),
meta.deploymentMode(),
false,
ctx,
ctxLdr,
meta.classLoaderId(),
meta.senderNodeId(),
meta.sequenceNumber(),
comm,
ctx.config().getNetworkTimeout(),
log,
ctx.config().getPeerClassLoadingClassPathExclude(),
ctx.config().getPeerClassLoadingMissedResourcesCacheSize(),
meta.deploymentMode() == CONTINUOUS /* enable class byte cache in CONTINUOUS mode */);
if (meta.participants() != null)
for (Map.Entry<UUID, GridTuple2<GridUuid, Long>> e : meta.participants().entrySet())
clsLdr.register(e.getKey(), e.getValue().get1(), e.getValue().get2());
if (log.isDebugEnabled())
log.debug(
"Created class loader in CONTINUOUS mode or without participants "
+ "[ldr="
+ clsLdr
+ ", meta="
+ meta
+ ']');
} else {
assert meta.deploymentMode() == SHARED;
// Create peer class loader.
// Note that we are passing empty list for local P2P exclude, as it really
// does not make sense with shared deployment.
clsLdr =
new GridDeploymentClassLoader(
ldrId,
meta.userVersion(),
meta.deploymentMode(),
false,
ctx,
ctxLdr,
meta.participants(),
comm,
ctx.config().getNetworkTimeout(),
log,
ctx.config().getPeerClassLoadingClassPathExclude(),
ctx.config().getPeerClassLoadingMissedResourcesCacheSize(),
false);
if (log.isDebugEnabled())
log.debug(
"Created classloader in SHARED mode with participants "
+ "[ldr="
+ clsLdr
+ ", meta="
+ meta
+ ']');
}
// Give this deployment a unique class loader to emphasize that this
// ID is unique to this shared deployment and is not ID of loader on
// sender node.
SharedDeployment dep =
new SharedDeployment(
meta.deploymentMode(), clsLdr, ldrId, -1, meta.userVersion(), meta.alias());
if (log.isDebugEnabled()) log.debug("Created new deployment: " + dep);
if (isCache) {
List<SharedDeployment> deps =
F.addIfAbsent(cache, meta.userVersion(), new LinkedList<SharedDeployment>());
assert deps != null;
deps.add(dep);
if (log.isDebugEnabled()) log.debug("Added deployment to cache: " + cache);
}
return dep;
}
/**
* Removes obsolete deployments in case of redeploy.
*
* @param meta Request metadata.
* @return List of shares deployment.
*/
private GridTuple2<Boolean, SharedDeployment> checkRedeploy(GridDeploymentMetadata meta) {
assert Thread.holdsLock(mux);
SharedDeployment newDep = null;
for (List<SharedDeployment> deps : cache.values()) {
for (SharedDeployment dep : deps) {
if (!dep.isUndeployed() && !dep.isPendingUndeploy()) {
long undeployTimeout = ctx.config().getNetworkTimeout();
SharedDeployment doomed = null;
// Only check deployments with no participants.
if (!dep.hasParticipants()) {
// In case of SHARED deployment it is possible to get hear if
// unmarshalling happens during undeploy. In this case, we
// simply don't do anything.
if (dep.deployMode() == CONTINUOUS) {
if (dep.existingDeployedClass(meta.className()) != null) {
// Change from shared deploy to shared undeploy or user version change.
// Simply remove all deployments with no participating nodes.
if (meta.deploymentMode() == SHARED
|| !meta.userVersion().equals(dep.userVersion())) doomed = dep;
}
}
}
// If there are participants, we undeploy if class loader ID on some node changed.
else if (dep.existingDeployedClass(meta.className()) != null) {
GridTuple2<GridUuid, Long> ldr = dep.getClassLoaderId(meta.senderNodeId());
if (ldr != null) {
if (!ldr.get1().equals(meta.classLoaderId())) {
// If deployed sequence number is less, then schedule for undeployment.
if (ldr.get2() < meta.sequenceNumber()) {
if (log.isDebugEnabled())
log.debug(
"Received request for a class with newer sequence number "
+ "(will schedule current class for undeployment) [newSeq="
+ meta.sequenceNumber()
+ ", oldSeq="
+ ldr.get2()
+ ", senderNodeId="
+ meta.senderNodeId()
+ ", newClsLdrId="
+ meta.classLoaderId()
+ ", oldClsLdrId="
+ ldr.get1()
+ ']');
doomed = dep;
} else if (ldr.get2() > meta.sequenceNumber()) {
long time = System.currentTimeMillis() - dep.timestamp();
if (newDep == null && time < ctx.config().getNetworkTimeout()) {
// Set undeployTimeout, so the class will be scheduled
// for undeployment.
undeployTimeout = ctx.config().getNetworkTimeout() - time;
if (log.isDebugEnabled())
log.debug(
"Received execution request for a stale class (will deploy and "
+ "schedule undeployment in "
+ undeployTimeout
+ "ms) "
+ "[curSeq="
+ ldr.get2()
+ ", staleSeq="
+ meta.sequenceNumber()
+ ", cls="
+ meta.className()
+ ", senderNodeId="
+ meta.senderNodeId()
+ ", curLdrId="
+ ldr.get1()
+ ", staleLdrId="
+ meta.classLoaderId()
+ ']');
// We got the redeployed class before the old one.
// Simply create a temporary deployment for the sender node,
// and schedule undeploy for it.
newDep = createNewDeployment(meta, false);
doomed = newDep;
} else {
U.warn(
log,
"Received execution request for a class that has been redeployed "
+ "(will ignore): "
+ meta.alias());
if (log.isDebugEnabled())
log.debug(
"Received execution request for a class that has been redeployed "
+ "(will ignore) [alias="
+ meta.alias()
+ ", dep="
+ dep
+ ']');
return F.t(false, null);
}
} else {
U.error(
log,
"Sequence number does not correspond to class loader ID [seqNum="
+ meta.sequenceNumber()
+ ", dep="
+ dep
+ ']');
return F.t(false, null);
}
}
}
}
if (doomed != null) {
doomed.onUndeployScheduled();
if (log.isDebugEnabled()) log.debug("Deployment was scheduled for undeploy: " + doomed);
// Lifespan time.
final long endTime = System.currentTimeMillis() + undeployTimeout;
// Deployment to undeploy.
final SharedDeployment undep = doomed;
ctx.timeout()
.addTimeoutObject(
new GridTimeoutObject() {
@Override
public GridUuid timeoutId() {
return undep.classLoaderId();
}
@Override
public long endTime() {
return endTime < 0 ? Long.MAX_VALUE : endTime;
}
@Override
public void onTimeout() {
boolean removed = false;
// Hot redeployment.
synchronized (mux) {
assert undep.isPendingUndeploy();
if (!undep.isUndeployed()) {
undep.undeploy();
undep.onRemoved();
removed = true;
Collection<SharedDeployment> deps = cache.get(undep.userVersion());
if (deps != null) {
for (Iterator<SharedDeployment> i = deps.iterator(); i.hasNext(); )
if (i.next() == undep) i.remove();
if (deps.isEmpty()) cache.remove(undep.userVersion());
}
if (log.isInfoEnabled())
log.info(
"Undeployed class loader due to deployment mode change, "
+ "user version change, or hot redeployment: "
+ undep);
}
}
// Outside synchronization.
if (removed) undep.recordUndeployed(null);
}
});
}
}
}
}
if (newDep != null) {
List<SharedDeployment> list =
F.addIfAbsent(cache, meta.userVersion(), F.<SharedDeployment>newList());
assert list != null;
list.add(newDep);
}
return F.t(true, newDep);
}
/**
* Gets property removed.
*
* @return Property removed.
*/
boolean isRemoved() {
assert Thread.holdsLock(mux);
return removed;
}
/** @return {@code True} if deployment has any node participants. */
boolean hasParticipants() {
assert Thread.holdsLock(mux);
return loader().hasRegisteredNodes();
}
/** @return Registered class loader IDs. */
Collection<GridUuid> getClassLoaderIds() {
assert Thread.holdsLock(mux);
return loader().registeredClassLoaderIds();
}
/** @return Set of participating nodes. */
Collection<UUID> getParticipantNodeIds() {
assert Thread.holdsLock(mux);
return loader().registeredNodeIds();
}