@SuppressWarnings("unchecked") private ServingModelManager<U> loadManagerInstance() { Class<?> managerClass = ClassUtils.loadClass(modelManagerClassName); if (ServingModelManager.class.isAssignableFrom(managerClass)) { try { return ClassUtils.loadInstanceOf( modelManagerClassName, ServingModelManager.class, new Class<?>[] { Config.class }, new Object[] { config }); } catch (IllegalArgumentException iae) { return ClassUtils.loadInstanceOf(modelManagerClassName, ServingModelManager.class); } } else if (ScalaServingModelManager.class.isAssignableFrom(managerClass)) { try { return new ScalaServingModelManagerAdapter<>(ClassUtils.loadInstanceOf( modelManagerClassName, ScalaServingModelManager.class, new Class<?>[] { Config.class }, new Object[] { config })); } catch (IllegalArgumentException iae) { return new ScalaServingModelManagerAdapter<>(ClassUtils.loadInstanceOf( modelManagerClassName, ScalaServingModelManager.class)); } } else { throw new IllegalArgumentException("Bad manager class: " + managerClass); } }
private Set<Class<?>> doGetClasses() { String packages = servletContext.getInitParameter(OryxApplication.class.getName() + ".packages"); log.info("Creating JAX-RS from endpoints in package(s) {}", packages); Objects.requireNonNull(packages); Set<Class<?>> classes = new HashSet<>(); for (String thePackage : packages.split(",")) { Reflections reflections = new Reflections(thePackage); classes.addAll(getClassesInPackageAnnotatedBy(thePackage, reflections, Path.class)); classes.addAll(getClassesInPackageAnnotatedBy(thePackage, reflections, Produces.class)); classes.addAll(getClassesInPackageAnnotatedBy(thePackage, reflections, Provider.class)); } // Want to configure these globally, but not depend on Jersey, even though it's // what will be used in practice by the provided apps. for (String optionalJerseyClass : new String[] { "org.glassfish.jersey.message.DeflateEncoder", "org.glassfish.jersey.message.GZipEncoder", "org.glassfish.jersey.server.filter.EncodingFilter"}) { if (ClassUtils.classExists(optionalJerseyClass)) { classes.add(ClassUtils.loadClass(optionalJerseyClass)); } } log.debug("Found JAX-RS resources: {}", classes); return classes; }
/** * @param implClassName class name to text * @return {@code true} if the class exists in the JVM and can be loaded */ public static boolean classExists(String implClassName) { try { forName(implClassName); return true; } catch (ClassNotFoundException ignored) { return false; } }
/** * Like {@link #loadInstanceOf(String, Class, Class[], Object[])} for no-arg constructors. * * @param implClassName implementation class name * @param superClass superclass or interface that the implementation extends * @param <T> type of returned instance * @return instance of {@code implClassName} */ public static <T> T loadInstanceOf(String implClassName, Class<T> superClass) { return loadInstanceOf(implClassName, superClass, NO_TYPES, NO_ARGS); }
@SuppressWarnings("unchecked") public SpeedLayer(Config config) { super(config); this.updateBroker = config.getString("oryx.update-topic.broker"); this.updateTopic = config.getString("oryx.update-topic.message.topic"); this.maxMessageSize = config.getInt("oryx.update-topic.message.max-size"); this.modelManagerClassName = config.getString("oryx.speed.model-manager-class"); this.updateDecoderClass = (Class<? extends Deserializer<U>>) ClassUtils.loadClass( config.getString("oryx.update-topic.message.decoder-class"), Deserializer.class); Preconditions.checkArgument(maxMessageSize > 0); }
@Test public void testNoContextCL() { Thread current = Thread.currentThread(); ClassLoader savedCL = current.getContextClassLoader(); current.setContextClassLoader(null); try { assertTrue(ClassUtils.classExists(ClassUtilsTest.class.getName())); } finally { current.setContextClassLoader(savedCL); } }
/** * Like {@link #loadInstanceOf(String, Class)} where the reference returned is of the same type as * the class being loaded -- not any supertype. * * @param clazz {@link Class} to make an instance of * @param <T> type of returned instance * @return instance of {@code clazz} */ public static <T> T loadInstanceOf(Class<T> clazz) { return loadInstanceOf(clazz.getName(), clazz); }
public BatchLayer(Config config) { super(config); this.keyWritableClass = ClassUtils.loadClass( config.getString("oryx.batch.storage.key-writable-class"), Writable.class); this.messageWritableClass = ClassUtils.loadClass( config.getString("oryx.batch.storage.message-writable-class"), Writable.class); this.updateClassName = config.getString("oryx.batch.update-class"); this.dataDirString = config.getString("oryx.batch.storage.data-dir"); this.modelDirString = config.getString("oryx.batch.storage.model-dir"); this.maxDataAgeHours = config.getInt("oryx.batch.storage.max-age-data-hours"); this.maxModelAgeHours = config.getInt("oryx.batch.storage.max-age-model-hours"); Preconditions.checkArgument(!dataDirString.isEmpty()); Preconditions.checkArgument(!modelDirString.isEmpty()); Preconditions.checkArgument(maxDataAgeHours >= 0 || maxDataAgeHours == NO_MAX_AGE); Preconditions.checkArgument(maxModelAgeHours >= 0 || maxModelAgeHours == NO_MAX_AGE); }
@Test public void testExists() { assertTrue(ClassUtils.classExists("java.lang.String")); assertTrue(ClassUtils.classExists("com.cloudera.oryx.common.lang.ClassUtils")); assertFalse(ClassUtils.classExists("java.Foo")); }
@SuppressWarnings("unchecked") private BatchLayerUpdate<K,M,U> loadUpdateInstance() { Class<?> updateClass = ClassUtils.loadClass(updateClassName); if (BatchLayerUpdate.class.isAssignableFrom(updateClass)) { try { return ClassUtils.loadInstanceOf( updateClassName, BatchLayerUpdate.class, new Class<?>[] { Config.class }, new Object[] { getConfig() }); } catch (IllegalArgumentException iae) { return ClassUtils.loadInstanceOf(updateClassName, BatchLayerUpdate.class); } } else if (ScalaBatchLayerUpdate.class.isAssignableFrom(updateClass)) { try { return new ScalaBatchLayerUpdateAdapter<>(ClassUtils.loadInstanceOf( updateClassName, ScalaBatchLayerUpdate.class, new Class<?>[] { Config.class }, new Object[] { getConfig() })); } catch (IllegalArgumentException iae) { return new ScalaBatchLayerUpdateAdapter<>(ClassUtils.loadInstanceOf( updateClassName, ScalaBatchLayerUpdate.class)); } } else { throw new IllegalArgumentException("Bad update class: " + updateClassName); } }
@Test(expected = IllegalStateException.class) public void tesInvocationException() { ClassUtils.loadInstanceOf(String.class.getName(), String.class, new Class<?>[] { char[].class }, new Object[] { null }); }
/** * Loads and instantiates a named implementation class, a subclass of a given supertype, * whose constructor takes the given arguments. * * @param implClassName implementation class name * @param superClass superclass or interface that the implementation extends * @param constructorTypes argument types of constructor to use * @param constructorArgs actual constructor arguments * @param <T> type of returned instance * @return instance of {@code implClassName} */ public static <T> T loadInstanceOf(String implClassName, Class<T> superClass, Class<?>[] constructorTypes, Object[] constructorArgs) { try { Class<? extends T> configClass = loadClass(implClassName, superClass); Constructor<? extends T> constructor = configClass.getConstructor(constructorTypes); return constructor.newInstance(constructorArgs); } catch (NoSuchMethodException | InstantiationException | IllegalAccessException e) { throw new IllegalArgumentException("No valid " + superClass + " binding exists", e); } catch (InvocationTargetException ite) { throw new IllegalStateException("Could not instantiate " + superClass + " due to exception", ite.getCause()); } }
/** * @param className fully-qualified class name, which should be known to be available * @param <T> expected type of returned {@link Class} * @return {@link Class} for that named class */ public static <T> Class<T> loadClass(String className) { try { @SuppressWarnings("unchecked") Class<T> theClass = (Class<T>) forName(className); return theClass; } catch (ClassNotFoundException cnfe) { throw new IllegalStateException("No valid " + className + " exists", cnfe); } }
@SuppressWarnings("unchecked") private SpeedModelManager<K,M,U> loadManagerInstance() { Class<?> managerClass = ClassUtils.loadClass(modelManagerClassName); if (SpeedModelManager.class.isAssignableFrom(managerClass)) { try { return ClassUtils.loadInstanceOf( modelManagerClassName, SpeedModelManager.class, new Class<?>[] { Config.class }, new Object[] { getConfig() }); } catch (IllegalArgumentException iae) { return ClassUtils.loadInstanceOf(modelManagerClassName, SpeedModelManager.class); } } else if (ScalaSpeedModelManager.class.isAssignableFrom(managerClass)) { try { return new ScalaSpeedModelManagerAdapter<>(ClassUtils.loadInstanceOf( modelManagerClassName, ScalaSpeedModelManager.class, new Class<?>[] { Config.class }, new Object[] { getConfig() })); } catch (IllegalArgumentException iae) { return new ScalaSpeedModelManagerAdapter<>(ClassUtils.loadInstanceOf( modelManagerClassName, ScalaSpeedModelManager.class)); } } else { throw new IllegalArgumentException("Bad manager class: " + managerClass); } }
@Test(expected = IllegalArgumentException.class) public void testNoSuchMethod() { ClassUtils.loadInstanceOf(Long.class.getName(), Long.class); }
@SuppressWarnings("unchecked") void init(ServletContext context) { String serializedConfig = context.getInitParameter(ConfigUtils.class.getName() + ".serialized"); Objects.requireNonNull(serializedConfig); this.config = ConfigUtils.deserialize(serializedConfig); this.updateTopic = config.getString("oryx.update-topic.message.topic"); this.maxMessageSize = config.getInt("oryx.update-topic.message.max-size"); this.updateTopicLockMaster = config.getString("oryx.update-topic.lock.master"); this.updateTopicBroker = config.getString("oryx.update-topic.broker"); this.readOnly = config.getBoolean("oryx.serving.api.read-only"); if (!readOnly) { this.inputTopic = config.getString("oryx.input-topic.message.topic"); this.inputTopicLockMaster = config.getString("oryx.input-topic.lock.master"); this.inputTopicBroker = config.getString("oryx.input-topic.broker"); } this.modelManagerClassName = config.getString("oryx.serving.model-manager-class"); this.updateDecoderClass = (Class<? extends Deserializer<U>>) ClassUtils.loadClass( config.getString("oryx.update-topic.message.decoder-class"), Deserializer.class); Preconditions.checkArgument(maxMessageSize > 0); }
/** * @param className fully-qualified class name, which should be known to be available * @param superClass reference type of returned {@link Class} * @param <T> type of returned {@link Class} * @return {@link Class} for that named class */ public static <T> Class<? extends T> loadClass(String className, Class<T> superClass) { try { return forName(className).asSubclass(superClass); } catch (ClassNotFoundException cnfe) { throw new IllegalStateException("No valid " + superClass + " binding exists", cnfe); } }
@SuppressWarnings("unchecked") private SpeedModelManager<K,M,U> loadManagerInstance() { Class<?> managerClass = ClassUtils.loadClass(modelManagerClassName); if (SpeedModelManager.class.isAssignableFrom(managerClass)) { try { return ClassUtils.loadInstanceOf( modelManagerClassName, SpeedModelManager.class, new Class<?>[] { Config.class }, new Object[] { getConfig() }); } catch (IllegalArgumentException iae) { return ClassUtils.loadInstanceOf(modelManagerClassName, SpeedModelManager.class); } } else if (ScalaSpeedModelManager.class.isAssignableFrom(managerClass)) { try { return new ScalaSpeedModelManagerAdapter<>(ClassUtils.loadInstanceOf( modelManagerClassName, ScalaSpeedModelManager.class, new Class<?>[] { Config.class }, new Object[] { getConfig() })); } catch (IllegalArgumentException iae) { return new ScalaSpeedModelManagerAdapter<>(ClassUtils.loadInstanceOf( modelManagerClassName, ScalaSpeedModelManager.class)); } } else { throw new IllegalArgumentException("Bad manager class: " + managerClass); } }
protected static byte[] compress( String data, Class<? extends OutputStream> compressingClass) { ByteArrayOutputStream bytes = new ByteArrayOutputStream(); try (OutputStream compressingStream = ClassUtils.loadInstanceOf(compressingClass.getName(), compressingClass, new Class<?>[]{OutputStream.class}, new Object[]{bytes})) { if (compressingStream instanceof ZipOutputStream) { ((ZipOutputStream) compressingStream).putNextEntry(new ZipEntry("data")); } compressingStream.write(data.getBytes(StandardCharsets.UTF_8)); if (compressingStream instanceof ZipOutputStream) { ((ZipOutputStream) compressingStream).closeEntry(); } compressingStream.flush(); } catch (IOException e) { // Can't happen throw new IllegalStateException(e); } return bytes.toByteArray(); }
@SuppressWarnings("unchecked") protected AbstractSparkLayer(Config config) { Objects.requireNonNull(config); log.info("Configuration:\n{}", ConfigUtils.prettyPrint(config)); String group = getConfigGroup(); this.config = config; String configuredID = ConfigUtils.getOptionalString(config, "oryx.id"); this.id = configuredID == null ? UUID.randomUUID().toString() : configuredID; this.streamingMaster = config.getString("oryx." + group + ".streaming.master"); this.inputTopic = config.getString("oryx.input-topic.message.topic"); this.inputTopicLockMaster = config.getString("oryx.input-topic.lock.master"); this.inputBroker = config.getString("oryx.input-topic.broker"); this.updateTopic = ConfigUtils.getOptionalString(config, "oryx.update-topic.message.topic"); this.updateTopicLockMaster = ConfigUtils.getOptionalString(config, "oryx.update-topic.lock.master"); this.keyClass = ClassUtils.loadClass(config.getString("oryx.input-topic.message.key-class")); this.messageClass = ClassUtils.loadClass(config.getString("oryx.input-topic.message.message-class")); this.keyDecoderClass = (Class<? extends Deserializer<K>>) ClassUtils.loadClass( config.getString("oryx.input-topic.message.key-decoder-class"), Deserializer.class); this.messageDecoderClass = (Class<? extends Deserializer<M>>) ClassUtils.loadClass( config.getString("oryx.input-topic.message.message-decoder-class"), Deserializer.class); this.generationIntervalSec = config.getInt("oryx." + group + ".streaming.generation-interval-sec"); this.extraSparkConfig = new HashMap<>(); config.getConfig("oryx." + group + ".streaming.config").entrySet().forEach(e -> extraSparkConfig.put(e.getKey(), e.getValue().unwrapped()) ); Preconditions.checkArgument(generationIntervalSec > 0); }