public static LedgerStorage createLedgerStorage(String name) throws IOException { try { return ReflectionUtils.newInstance(name, LedgerStorage.class); } catch (Throwable t) { throw new IOException("Failed to instantiate ledger storage : " + name, t); } } }
public static MetaStore createMetaStore(String name) throws MetastoreException { try { return ReflectionUtils.newInstance(name, MetaStore.class); } catch (Throwable t) { throw new MetastoreException("Failed to instantiate metastore : " + name); } }
/** * Create an object using the given class name. * * @param clsName * class name of which an object is created. * @param xface * The interface implemented by the named class. * @return a new object */ @SuppressWarnings("unchecked") public static <T> T newInstance(String clsName, Class<T> xface) { Class<?> theCls; try { theCls = Class.forName(clsName); } catch (ClassNotFoundException cnfe) { throw new RuntimeException(cnfe); } if (!xface.isAssignableFrom(theCls)) { throw new RuntimeException(clsName + " not " + xface.getName()); } return newInstance(theCls.asSubclass(xface)); } }
/** * Retrieve the client driver for {@code scheme}. * * @param scheme the scheme for the metadata client driver * @return the metadata client driver * @throws NullPointerException when scheme is null */ public static MetadataClientDriver getClientDriver(String scheme) { checkNotNull(scheme, "Client Driver Scheme is null"); if (!initialized) { initialize(); } MetadataClientDriverInfo driverInfo = clientDrivers.get(scheme.toLowerCase()); if (null == driverInfo) { throw new IllegalArgumentException("Unknown backend " + scheme); } return ReflectionUtils.newInstance(driverInfo.driverClass); }
/** * Retrieve the namespace driver for {@code scheme}. * * @param scheme the scheme for the namespace driver * @return the namespace driver * @throws NullPointerException when scheme is null */ public static NamespaceDriver getDriver(String scheme) { checkNotNull(scheme, "Driver Scheme is null"); if (!initialized) { initialize(); } NamespaceDriverInfo driverInfo = drivers.get(scheme.toLowerCase()); if (null == driverInfo) { throw new IllegalArgumentException("Unknown backend " + scheme); } return ReflectionUtils.newInstance(driverInfo.driverClass); }
/** * Retrieve the bookie driver for {@code scheme}. * * @param scheme the scheme for the metadata bookie driver * @return the metadata bookie driver * @throws NullPointerException when scheme is null */ public static MetadataBookieDriver getBookieDriver(String scheme) { checkNotNull(scheme, "Bookie Driver Scheme is null"); if (!initialized) { initialize(); } MetadataBookieDriverInfo driverInfo = bookieDrivers.get(scheme.toLowerCase()); if (null == driverInfo) { throw new IllegalArgumentException("Unknown backend " + scheme); } return ReflectionUtils.newInstance(driverInfo.driverClass); }
public static LedgerIdFormatter newLedgerIdFormatter(AbstractConfiguration<?> conf) { LedgerIdFormatter formatter; try { Class<? extends LedgerIdFormatter> ledgerIdFormatterClass = conf.getLedgerIdFormatterClass(); formatter = ReflectionUtils.newInstance(ledgerIdFormatterClass); } catch (Exception e) { LOG.warn("No formatter class found", e); LOG.warn("Using Default Long Formatter."); formatter = new LongLedgerIdFormatter(); } return formatter; }
public static EntryFormatter newEntryFormatter(AbstractConfiguration<?> conf) { EntryFormatter formatter; try { Class<? extends EntryFormatter> entryFormatterClass = conf.getEntryFormatterClass(); formatter = ReflectionUtils.newInstance(entryFormatterClass); } catch (Exception e) { LOG.warn("No formatter class found", e); LOG.warn("Using Default String Formatter."); formatter = new StringEntryFormatter(); } return formatter; }
public static void main(String args[]) { int rc = -1; if (args.length <= 0) { System.err.println("No tool to run."); System.err.println(""); System.err.println("Usage : Tool <tool_class_name> <options>"); System.exit(-1); } String toolClass = args[0]; try { Tool tool = ReflectionUtils.newInstance(toolClass, Tool.class); String[] newArgs = new String[args.length - 1]; System.arraycopy(args, 1, newArgs, 0, newArgs.length); rc = tool.run(newArgs); } catch (Throwable t) { System.err.println("Fail to run tool " + toolClass + " : "); t.printStackTrace(); } System.exit(rc); } }
private EnsemblePlacementPolicy initializeEnsemblePlacementPolicy(ClientConfiguration conf, DNSToSwitchMapping dnsResolver, HashedWheelTimer timer, FeatureProvider featureProvider, StatsLogger statsLogger) throws IOException { try { Class<? extends EnsemblePlacementPolicy> policyCls = conf.getEnsemblePlacementPolicy(); return ReflectionUtils.newInstance(policyCls).initialize(conf, java.util.Optional.ofNullable(dnsResolver), timer, featureProvider, statsLogger); } catch (ConfigurationException e) { throw new IOException("Failed to initialize ensemble placement policy : ", e); } }
public static SecurityHandlerFactory getSecurityProviderFactory(String securityHandler) throws SecurityException { if ((securityHandler == null) || (securityHandler.equals(""))) { return null; } SecurityHandlerFactory shFactory; try { Class<? extends SecurityHandlerFactory> shFactoryClass = ReflectionUtils.forName(securityHandler, SecurityHandlerFactory.class); shFactory = ReflectionUtils.newInstance(shFactoryClass); LOG.info("Loaded security handler for {}", securityHandler); } catch (RuntimeException re) { LOG.error("Unable to load security handler for {}: ", securityHandler, re.getCause()); throw new SecurityException(re.getCause()); } return shFactory; }
private static void loadInitialDrivers() { Set<String> driverList = Sets.newHashSet(); // add default bookkeeper based driver driverList.add(BKNamespaceDriver.class.getName()); // load drivers from system property String driversStr = System.getProperty("distributedlog.namespace.drivers"); if (null != driversStr) { String[] driversArray = StringUtils.split(driversStr, ':'); for (String driver : driversArray) { driverList.add(driver); } } // initialize the drivers for (String driverClsName : driverList) { try { NamespaceDriver driver = ReflectionUtils.newInstance(driverClsName, NamespaceDriver.class); NamespaceDriverInfo driverInfo = new NamespaceDriverInfo(driver.getClass()); drivers.put(driver.getScheme().toLowerCase(), driverInfo); } catch (Exception ex) { logger.warn("Failed to load namespace driver {} : ", driverClsName, ex); } } }
private static void loadInitialClientDrivers() { Set<String> driverList = Sets.newHashSet(); // add default zookeeper based driver driverList.add(ZK_CLIENT_DRIVER_CLASS); // load drivers from system property String driversStr = System.getProperty(BK_METADATA_CLIENT_DRIVERS_PROPERTY); if (null != driversStr) { String[] driversArray = StringUtils.split(driversStr, ':'); for (String driver : driversArray) { driverList.add(driver); } } // initialize the drivers for (String driverClsName : driverList) { try { MetadataClientDriver driver = ReflectionUtils.newInstance(driverClsName, MetadataClientDriver.class); MetadataClientDriverInfo driverInfo = new MetadataClientDriverInfo(driver.getClass()); clientDrivers.put(driver.getScheme().toLowerCase(), driverInfo); } catch (Exception e) { log.warn("Failed to load metadata client driver {}", driverClsName, e); } } }
private static void loadInitialBookieDrivers() { Set<String> driverList = Sets.newHashSet(); // add default zookeeper based driver driverList.add(ZK_BOOKIE_DRIVER_CLASS); // load drivers from system property String driversStr = System.getProperty(BK_METADATA_BOOKIE_DRIVERS_PROPERTY); if (null != driversStr) { String[] driversArray = StringUtils.split(driversStr, ':'); for (String driver : driversArray) { driverList.add(driver); } } // initialize the drivers for (String driverClsName : driverList) { try { MetadataBookieDriver driver = ReflectionUtils.newInstance(driverClsName, MetadataBookieDriver.class); MetadataBookieDriverInfo driverInfo = new MetadataBookieDriverInfo(driver.getClass()); bookieDrivers.put(driver.getScheme().toLowerCase(), driverInfo); } catch (Exception e) { log.warn("Failed to load metadata bookie driver {}", driverClsName, e); } } }
public StatsProviderService(BookieConfiguration conf) throws Exception { super(NAME, conf, NullStatsLogger.INSTANCE); Class<? extends StatsProvider> statsProviderClass = conf.getServerConf().getStatsProviderClass(); this.statsProvider = ReflectionUtils.newInstance(statsProviderClass); }
public static ClientAuthProvider.Factory newClientAuthProviderFactory(ClientConfiguration conf) throws IOException { String factoryClassName = conf.getClientAuthProviderFactoryClass(); if (factoryClassName == null || factoryClassName.length() == 0) { return new NullClientAuthProviderFactory(); } ClientAuthProvider.Factory factory = ReflectionUtils.newInstance(factoryClassName, ClientAuthProvider.Factory.class); factory.init(conf); return factory; }
public static BookieAuthProvider.Factory newBookieAuthProviderFactory(ServerConfiguration conf) throws IOException { String factoryClassName = conf.getBookieAuthProviderFactoryClass(); if (factoryClassName == null || factoryClassName.length() == 0) { return new AuthenticationDisabledAuthProviderFactory(); } BookieAuthProvider.Factory factory = ReflectionUtils.newInstance(factoryClassName, BookieAuthProvider.Factory.class); factory.init(conf); return factory; }
lmFactory = ReflectionUtils.newInstance(factoryClass);
String dnsResolverName = conf.getString(REPP_DNS_RESOLVER_CLASS, ScriptBasedMapping.class.getName()); try { dnsResolver = ReflectionUtils.newInstance(dnsResolverName, DNSToSwitchMapping.class); if (dnsResolver instanceof Configurable) { ((Configurable) dnsResolver).setConf(conf);
NameResolverFactoryProvider provider; try { provider = ReflectionUtils.newInstance( BK_REG_NAME_RESOLVER_PROVIDER, NameResolverFactoryProvider.class);