/** {@inheritDoc} */
@Nullable
@Override
public GridDeployment explicitDeploy(Class<?> cls, ClassLoader clsLdr) throws GridException {
try {
// Make sure not to deploy peer loaded tasks with non-local class loader,
// if local one exists.
if (clsLdr.getClass().equals(GridDeploymentClassLoader.class)) clsLdr = clsLdr.getParent();
GridDeployment dep;
synchronized (mux) {
boolean deployed = spi.register(clsLdr, cls);
if (deployed) {
dep = getDeployment(cls.getName());
if (dep == null) {
GridDeploymentResource rsrc = spi.findResource(cls.getName());
if (rsrc != null && rsrc.getClassLoader() == clsLdr) {
dep =
deploy(
ctx.config().getDeploymentMode(),
rsrc.getClassLoader(),
rsrc.getResourceClass(),
rsrc.getName());
}
}
if (dep != null) {
recordDeploy(cls, cls.getName(), true);
}
} else {
dep = getDeployment(cls.getName());
}
}
return dep;
} catch (GridSpiException e) {
recordDeployFailed(cls, clsLdr, true);
// Avoid double wrapping.
if (e.getCause() instanceof GridException) {
throw (GridException) e.getCause();
}
throw new GridException("Failed to deploy class: " + cls.getName(), e);
}
}
/** {@inheritDoc} */
@Override
public URL getResource(String name) {
URL url = findResource(name);
if (url == null) url = ClassLoader.getSystemResource(name);
if (url == null) url = super.getResource(name);
return url;
}
/** {@inheritDoc} */
@Override
public InputStream getResourceAsStream(String name) {
// Find resource in GAR file first.
InputStream in = getResourceAsStreamGarOnly(name);
// Find resource in parent class loader.
if (in == null) in = ClassLoader.getSystemResourceAsStream(name);
if (in == null) in = super.getResourceAsStream(name);
return in;
}
/** {@inheritDoc} */
@Nullable
@SuppressWarnings({"UnusedCatchParameter"})
@Override
public GridDeployment getDeployment(GridDeploymentMetadata meta) {
GridDeployment dep;
Class<?> cls = null;
String alias = meta.alias();
synchronized (mux) {
// Validate metadata.
assert meta.alias() != null;
dep = getDeployment(meta.alias());
if (dep != null) {
if (log.isDebugEnabled()) {
log.debug("Acquired deployment class from local cache: " + dep);
}
return dep;
}
GridDeploymentResource rsrc = spi.findResource(meta.alias());
if (rsrc != null) {
dep =
deploy(
ctx.config().getDeploymentMode(),
rsrc.getClassLoader(),
rsrc.getResourceClass(),
alias);
if (dep == null) {
return null;
}
if (log.isDebugEnabled()) {
log.debug("Acquired deployment class from SPI: " + dep);
}
}
// Auto-deploy.
else {
ClassLoader ldr = meta.classLoader();
if (ldr == null) {
ldr = Thread.currentThread().getContextClassLoader();
// Safety.
if (ldr == null) {
ldr = ctxLdr;
}
}
// Don't auto-deploy locally in case of nested execution.
if (ldr instanceof GridDeploymentClassLoader) {
return null;
}
try {
// Check that class can be loaded.
cls = ldr.loadClass(meta.alias());
spi.register(ldr, cls);
rsrc = spi.findResource(alias);
if (rsrc != null && rsrc.getResourceClass().equals(cls)) {
if (log.isDebugEnabled()) {
log.debug("Retrieved auto-loaded resource from spi: " + rsrc);
}
dep = deploy(ctx.config().getDeploymentMode(), ldr, cls, alias);
if (dep == null) {
return null;
}
} else {
U.warn(
log,
"Failed to find resource from deployment SPI even after registering it: "
+ meta.alias());
return null;
}
} catch (ClassNotFoundException e) {
if (log.isDebugEnabled()) {
log.debug(
"Failed to load class for local auto-deployment [ldr="
+ ldr
+ ", meta="
+ meta
+ ']');
}
return null;
} catch (GridSpiException e) {
U.error(log, "Failed to deploy local class: " + meta.alias(), e);
return null;
}
}
}
if (cls != null) {
recordDeploy(cls, alias, meta.isRecord());
dep.addDeployedClass(cls, meta.className(), meta.alias());
}
if (log.isDebugEnabled()) {
log.debug("Acquired deployment class: " + dep);
}
return dep;
}
/** {@inheritDoc} */
@Override
public GridDeployment getDeployment(GridDeploymentMetadata meta) {
assert meta != null;
assert ctx.config().isPeerClassLoadingEnabled();
// Validate metadata.
assert meta.classLoaderId() != null;
assert meta.senderNodeId() != null;
assert meta.sequenceNumber() >= -1;
assert meta.parentLoader() == null;
if (log.isDebugEnabled())
log.debug("Starting to peer-load class based on deployment metadata: " + meta);
while (true) {
List<SharedDeployment> depsToCheck = null;
SharedDeployment dep = null;
synchronized (mux) {
// Check obsolete request.
if (isDeadClassLoader(meta)) return null;
List<SharedDeployment> deps = cache.get(meta.userVersion());
if (deps != null) {
assert !deps.isEmpty();
for (SharedDeployment d : deps) {
if (d.hasParticipant(meta.senderNodeId(), meta.classLoaderId())
|| meta.senderNodeId().equals(ctx.localNodeId())) {
// Done.
dep = d;
break;
}
}
if (dep == null) {
GridTuple2<Boolean, SharedDeployment> redeployCheck = checkRedeploy(meta);
if (!redeployCheck.get1()) {
// Checking for redeployment encountered invalid state.
if (log.isDebugEnabled())
log.debug("Checking for redeployment encountered invalid state: " + meta);
return null;
}
dep = redeployCheck.get2();
if (dep == null) {
// Find existing deployments that need to be checked
// whether they should be reused for this request.
for (SharedDeployment d : deps) {
if (!d.isPendingUndeploy() && !d.isUndeployed()) {
if (depsToCheck == null) depsToCheck = new LinkedList<SharedDeployment>();
if (log.isDebugEnabled()) log.debug("Adding deployment to check: " + d);
depsToCheck.add(d);
}
}
// If no deployment can be reused, create a new one.
if (depsToCheck == null) {
dep = createNewDeployment(meta, false);
deps.add(dep);
}
}
}
} else {
GridTuple2<Boolean, SharedDeployment> redeployCheck = checkRedeploy(meta);
if (!redeployCheck.get1()) {
// Checking for redeployment encountered invalid state.
if (log.isDebugEnabled())
log.debug("Checking for redeployment encountered invalid state: " + meta);
return null;
}
dep = redeployCheck.get2();
if (dep == null)
// Create peer class loader.
dep = createNewDeployment(meta, true);
}
}
if (dep != null) {
if (log.isDebugEnabled())
log.debug("Found SHARED or CONTINUOUS deployment after first check: " + dep);
// Cache the deployed class.
Class<?> cls = dep.deployedClass(meta.className(), meta.alias());
if (cls == null) {
U.warn(
log,
"Failed to load peer class (ignore if class got undeployed during preloading) [alias="
+ meta.alias()
+ ", dep="
+ dep
+ ']');
return null;
}
return dep;
}
assert meta.parentLoader() == null;
assert depsToCheck != null;
assert !depsToCheck.isEmpty();
/*
* Logic below must be performed outside of synchronization
* because it involves network calls.
*/
// Check if class can be loaded from existing nodes.
// In most cases this loop will find something.
for (SharedDeployment d : depsToCheck) {
// Load class. Note, that remote node will not load this class.
// The class will only be loaded on this node.
Class<?> cls = d.deployedClass(meta.className(), meta.alias());
if (cls != null) {
synchronized (mux) {
if (!d.isUndeployed() && !d.isPendingUndeploy()) {
if (!addParticipant(d, meta)) return null;
if (log.isDebugEnabled())
log.debug(
"Acquired deployment after verifying it's availability on "
+ "existing nodes [depCls="
+ cls
+ ", dep="
+ d
+ ", meta="
+ meta
+ ']');
return d;
}
}
} else if (log.isDebugEnabled()) {
log.debug(
"Deployment cannot be reused (class does not exist on participating nodes) [dep="
+ d
+ ", meta="
+ meta
+ ']');
}
}
// We are here either because all participant nodes failed
// or the class indeed should have a separate deployment.
for (SharedDeployment d : depsToCheck) {
// Temporary class loader.
ClassLoader temp =
new GridDeploymentClassLoader(
GridUuid.randomUuid(),
meta.userVersion(),
meta.deploymentMode(),
true,
ctx,
ctxLdr,
meta.classLoaderId(),
meta.senderNodeId(),
meta.sequenceNumber(),
comm,
ctx.config().getNetworkTimeout(),
log,
ctx.config().getPeerClassLoadingClassPathExclude(),
0,
false);
String path = U.classNameToResourceName(d.sampleClassName());
// We check if any random class from existing deployment can be
// loaded from sender node. If it can, then we reuse existing
// deployment.
InputStream rsrcIn = temp.getResourceAsStream(path);
if (rsrcIn != null) {
// We don't need the actual stream.
U.closeQuiet(rsrcIn);
synchronized (mux) {
if (d.isUndeployed() || d.isPendingUndeploy()) continue;
// Add new node prior to loading the class, so we attempt
// to load the class from the latest node.
if (!addParticipant(d, meta)) {
if (log.isDebugEnabled())
log.debug(
"Failed to add participant to deployment "
+ "[meta="
+ meta
+ ", dep="
+ dep
+ ']');
return null;
}
}
Class<?> depCls = d.deployedClass(meta.className(), meta.alias());
if (depCls == null) {
U.error(
log,
"Failed to peer load class after loading it as a resource [alias="
+ meta.alias()
+ ", dep="
+ dep
+ ']');
return null;
}
if (log.isDebugEnabled())
log.debug(
"Acquired deployment class after verifying other class "
+ "availability on sender node [depCls="
+ depCls
+ ", rndCls="
+ d.sampleClass()
+ ", sampleClsName="
+ d.sampleClassName()
+ ", meta="
+ meta
+ ']');
return d;
} else if (log.isDebugEnabled())
log.debug(
"Deployment cannot be reused (random class could not be loaded from sender node) [dep="
+ d
+ ", meta="
+ meta
+ ']');
}
synchronized (mux) {
if (log.isDebugEnabled())
log.debug(
"None of the existing class-loaders fit (will try to create a new one): " + meta);
// Check obsolete request.
if (isDeadClassLoader(meta)) return null;
// Check that deployment picture has not changed.
List<SharedDeployment> deps = cache.get(meta.userVersion());
if (deps != null) {
assert !deps.isEmpty();
boolean retry = false;
for (SharedDeployment d : deps) {
// Double check if sender was already added.
if (d.hasParticipant(meta.senderNodeId(), meta.classLoaderId())) {
dep = d;
retry = false;
break;
}
// New deployment was added while outside of synchronization.
// Need to recheck it again.
if (!d.isPendingUndeploy() && !d.isUndeployed() && !depsToCheck.contains(d))
retry = true;
}
if (retry) {
if (log.isDebugEnabled()) log.debug("Retrying due to concurrency issues: " + meta);
// Outer while loop.
continue;
}
if (dep == null) {
// No new deployments were added, so we can safely add ours.
dep = createNewDeployment(meta, false);
deps.add(dep);
if (log.isDebugEnabled())
log.debug(
"Adding new deployment within second check [dep=" + dep + ", meta=" + meta + ']');
}
} else {
dep = createNewDeployment(meta, true);
if (log.isDebugEnabled())
log.debug(
"Created new deployment within second check [dep=" + dep + ", meta=" + meta + ']');
}
}
if (dep != null) {
// Cache the deployed class.
Class<?> cls = dep.deployedClass(meta.className(), meta.alias());
if (cls == null) {
U.warn(
log,
"Failed to load peer class (ignore if class got undeployed during preloading) [alias="
+ meta.alias()
+ ", dep="
+ dep
+ ']');
return null;
}
}
return dep;
}
}