/** {@inheritDoc} */
@Override
public void deploy(final DeploymentPhaseContext phaseContext)
throws DeploymentUnitProcessingException {
final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
final Module module = deploymentUnit.getAttachment(Attachments.MODULE);
final ServicesAttachment servicesAttachment =
deploymentUnit.getAttachment(Attachments.SERVICES);
if (module != null && servicesAttachment != null) {
final ModuleClassLoader classLoader = module.getClassLoader();
final List<String> driverNames =
servicesAttachment.getServiceImplementations(Driver.class.getName());
for (String driverClassName : driverNames) {
try {
final Class<? extends Driver> driverClass =
classLoader.loadClass(driverClassName).asSubclass(Driver.class);
final Constructor<? extends Driver> constructor = driverClass.getConstructor();
final Driver driver = constructor.newInstance();
final int majorVersion = driver.getMajorVersion();
final int minorVersion = driver.getMinorVersion();
final boolean compliant = driver.jdbcCompliant();
if (compliant) {
log.infof(
"Deploying JDBC-compliant driver %s (version %d.%d)",
driverClass, Integer.valueOf(majorVersion), Integer.valueOf(minorVersion));
} else {
log.infof(
"Deploying non-JDBC-compliant driver %s (version %d.%d)",
driverClass, Integer.valueOf(majorVersion), Integer.valueOf(minorVersion));
}
String driverName = deploymentUnit.getName();
InstalledDriver driverMetadata =
new InstalledDriver(
driverName, driverClass.getName(), null, majorVersion, minorVersion, compliant);
DriverService driverService = new DriverService(driverMetadata, driver);
phaseContext
.getServiceTarget()
.addService(
ServiceName.JBOSS.append("jdbc-driver", driverName.replaceAll(".", "_")),
driverService)
.addDependency(
ConnectorServices.JDBC_DRIVER_REGISTRY_SERVICE,
DriverRegistry.class,
driverService.getDriverRegistryServiceInjector())
.setInitialMode(Mode.ACTIVE)
.install();
} catch (Exception e) {
log.warnf("Unable to instantiate driver class \"%s\": %s", driverClassName, e);
}
}
}
}
@Override
public Class<?> loadClassLocal(String className, boolean resolve) {
List<XPackageRequirement> matchingPatterns = findMatchingPatterns(className);
if (matchingPatterns.isEmpty()) return null;
String pathName = className.replace('.', '/') + ".class";
Module module = findModuleDynamically(pathName, matchingPatterns);
if (module == null) return null;
ModuleClassLoader moduleClassLoader = module.getClassLoader();
try {
return moduleClassLoader.loadClass(className);
} catch (ClassNotFoundException ex) {
log.tracef("Cannot load class [%s] from module: %s", className, module);
return null;
}
}
public Set<Class> getUpdatedClasses(
final String deploymentName, Map<String, Long> updatedClasses) {
final ModuleIdentifier moduleId = getModuleIdentifier(deploymentName);
final ModuleClassLoader loader = loadersByModuleIdentifier.get(moduleId);
if (loader == null) {
return Collections.emptySet();
}
final Map<String, Long> timestamps = this.timestamps.get(loader);
final Set<Class> ret = new HashSet<Class>();
for (Map.Entry<String, Long> entry : updatedClasses.entrySet()) {
if (timestamps.containsKey(entry.getKey())
&& timestamps.get(entry.getKey()) < entry.getValue()) {
try {
ret.add(loader.loadClass(entry.getKey()));
timestamps.put(entry.getKey(), entry.getValue());
} catch (ClassNotFoundException e) {
System.err.println("Could not load class " + entry);
}
}
}
return ret;
}
private static StandaloneServer create(
ModuleLoader moduleLoader, File jbossHomeDir, String bundlePath, String[] cmdargs) {
setupBundlePath(bundlePath);
setupVfsModule(moduleLoader);
setupLoggingSystem(moduleLoader);
// Embedded Server wants this, too. Seems redundant, but supply it.
WildFlySecurityManager.setPropertyPrivileged(
SYSPROP_KEY_JBOSS_HOME_DIR, jbossHomeDir.getAbsolutePath());
// Load the Embedded Server Module
final Module embeddedModule;
try {
embeddedModule = moduleLoader.loadModule(ModuleIdentifier.create(MODULE_ID_EMBEDDED));
} catch (final ModuleLoadException mle) {
throw EmbeddedLogger.ROOT_LOGGER.moduleLoaderError(mle, MODULE_ID_EMBEDDED, moduleLoader);
}
// Load the Embedded Server Factory via the modular environment
final ModuleClassLoader embeddedModuleCL = embeddedModule.getClassLoader();
final Class<?> embeddedServerFactoryClass;
final Class<?> standaloneServerClass;
try {
embeddedServerFactoryClass =
embeddedModuleCL.loadClass(EmbeddedStandAloneServerFactory.class.getName());
standaloneServerClass = embeddedModuleCL.loadClass(StandaloneServer.class.getName());
} catch (final ClassNotFoundException cnfe) {
throw EmbeddedLogger.ROOT_LOGGER.cannotLoadEmbeddedServerFactory(
cnfe, EmbeddedStandAloneServerFactory.class.getName());
}
// Get a handle to the method which will create the server
final Method createServerMethod;
try {
createServerMethod =
embeddedServerFactoryClass.getMethod(
"create",
File.class,
ModuleLoader.class,
Properties.class,
Map.class,
String[].class);
} catch (final NoSuchMethodException nsme) {
throw EmbeddedLogger.ROOT_LOGGER.cannotGetReflectiveMethod(
nsme, "create", embeddedServerFactoryClass.getName());
}
// Create the server
Object standaloneServerImpl;
try {
Properties sysprops = WildFlySecurityManager.getSystemPropertiesPrivileged();
Map<String, String> sysenv = WildFlySecurityManager.getSystemEnvironmentPrivileged();
String[] args = cmdargs != null ? cmdargs : new String[0];
standaloneServerImpl =
createServerMethod.invoke(null, jbossHomeDir, moduleLoader, sysprops, sysenv, args);
} catch (final InvocationTargetException ite) {
throw EmbeddedLogger.ROOT_LOGGER.cannotCreateStandaloneServer(
ite.getCause(), createServerMethod);
} catch (final IllegalAccessException iae) {
throw EmbeddedLogger.ROOT_LOGGER.cannotCreateStandaloneServer(iae, createServerMethod);
}
return new StandaloneServerIndirection(standaloneServerClass, standaloneServerImpl);
}
