public static void init( String encoderPluginId ) throws KettleException { if ( Utils.isEmpty( encoderPluginId ) ) { throw new KettleException( "Unable to initialize the two way password encoder: No encoder plugin type specified." ); } PluginRegistry registry = PluginRegistry.getInstance(); PluginInterface plugin = registry.findPluginWithId( TwoWayPasswordEncoderPluginType.class, encoderPluginId ); if ( plugin == null ) { throw new KettleException( "Unable to find plugin with ID '" + encoderPluginId + "'" ); } encoder = (TwoWayPasswordEncoderInterface) registry.loadClass( plugin ); // Load encoder specific options... // encoder.init(); }
public static PluginInterface getPlugin( JobEntryInterface jobEntryInterface ) { return PluginRegistry.getInstance().getPlugin( JobEntryPluginType.class, jobEntryInterface ); }
public void registerPlugin( URLClassLoader classLoader, Class<? extends AuthenticationConsumerType> clazz ) throws KettlePluginException { AuthenticationConsumerPlugin pluginAnnotation = clazz.getAnnotation( AuthenticationConsumerPlugin.class ); AuthenticationConsumerPluginType.getInstance().handlePluginAnnotation( clazz, pluginAnnotation, new ArrayList<String>(), false, null ); PluginRegistry.getInstance().addClassLoader( classLoader, PluginRegistry.getInstance().getPlugin( AuthenticationConsumerPluginType.class, pluginAnnotation.id() ) ); }
private StepMetaInterface getNewMeta() throws KettleException { PluginRegistry pluginRegistry = PluginRegistry.getInstance(); String id = pluginRegistry.getPluginId( StepPluginType.class, this ); PluginInterface plugin = pluginRegistry.getPlugin( StepPluginType.class, id ); return (StepMetaInterface) pluginRegistry.loadClass( plugin ); } }
public PluginInterface findPluginWithId( Class<? extends PluginTypeInterface> pluginType, String pluginId, boolean waitForPluginToBeAvailable ) { PluginInterface pluginInterface = findPluginWithId( pluginType, pluginId ); return waitForPluginToBeAvailable && pluginInterface == null ? waitForPluginToBeAvailable( pluginType, pluginId, WAIT_FOR_PLUGIN_TO_BE_AVAILABLE_LIMIT ) : pluginInterface; }
public PurRepositoryProxy( PluginRegistry registry ) throws KettlePluginException { PluginInterface purPlugin = registry.findPluginWithId( RepositoryPluginType.class, PUR_PLUGIN_ID ); purPluginClassLoader = registry.getClassLoader( purPlugin ); }
private CartePluginInterface loadServlet( PluginInterface plugin ) throws KettlePluginException { return PluginRegistry.getInstance().loadClass( plugin, CartePluginInterface.class ); }
public void setEntry( JobEntryInterface je ) { entry = je; if ( entry != null ) { if ( entry.getPluginId() == null ) { entry.setPluginId( PluginRegistry.getInstance().getPluginId( JobEntryPluginType.class, entry ) ); } setDeprecationAndSuggestedJobEntry(); } }
/** * Gets the plug-in type description * * @return the plug-in type description */ public String getTypeDesc() { PluginInterface plugin = PluginRegistry.getInstance().findPluginWithId( JobEntryPluginType.class, configId ); return plugin.getDescription(); }
protected void registerExtraDatabaseType( String id, String description, String mainClass ) throws KettlePluginException { Map<Class<?>, String> classMap = new HashMap<Class<?>, String>(); classMap.put( DatabaseInterface.class, mainClass ); PluginInterface dbPlugin = new Plugin( new String[] { id }, DatabasePluginType.class, DatabaseInterface.class, "", description, description, null, false, false, classMap, new ArrayList<String>(), null, null, null, null, null ); PluginRegistry.getInstance().addClassLoader( (URLClassLoader) Thread.currentThread().getContextClassLoader().getParent(), dbPlugin ); PluginRegistry.getInstance().registerPlugin( DatabasePluginType.class, dbPlugin ); }
@Override public String toString() { // The rule name with an indication of whether or not this rule is enabled should do for now. // String pluginId = PluginRegistry.getInstance().getPluginId( this ); PluginInterface plugin = PluginRegistry.getInstance().findPluginWithId( ImportRulePluginType.class, pluginId ); return plugin.getName() + " (" + ( enabled ? "enabled" : "disabled" ) + ")."; }
@Override Object doCall() throws Exception { List<PluginInterface> registered = new ArrayList<PluginInterface>( cycles ); try { for ( int i = 0; i < cycles; i++ ) { String id = nameSeed + '_' + i; PluginInterface mock = mock( PluginInterface.class ); when( mock.getName() ).thenReturn( id ); when( mock.getIds() ).thenReturn( new String[] { id } ); when( mock.getPluginType() ).thenAnswer( new Answer<Object>() { @Override public Object answer( InvocationOnMock invocation ) throws Throwable { return type; } } ); registered.add( mock ); PluginRegistry.getInstance().registerPlugin( type, mock ); } } finally { // push up registered instances for future clean-up addUsedPlugins( type, registered ); } return null; } }
@Test public void testEscapeCharacters() throws KettleException, IOException { PluginRegistry.addPluginType( ValueMetaPluginType.getInstance() ); PluginRegistry.init( false ); transMeta.setName( "loader" ); PluginRegistry plugReg = PluginRegistry.getInstance(); String loaderPid = plugReg.getPluginId( StepPluginType.class, lm ); StepMeta stepMeta = new StepMeta( loaderPid, "loader", lm ); Trans trans = new Trans( transMeta );
private void setDeprecationAndSuggestedStep() { PluginRegistry registry = PluginRegistry.getInstance(); final List<PluginInterface> deprecatedSteps = registry.getPluginsByCategory( StepPluginType.class, BaseMessages.getString( PKG, "BaseStep.Category.Deprecated" ) ); for ( PluginInterface p : deprecatedSteps ) { String[] ids = p.getIds(); if ( !ArrayUtils.isEmpty( ids ) && ids[0].equals( this.stepid ) ) { this.isDeprecated = true; this.suggestion = registry.findPluginWithId( StepPluginType.class, this.stepid ) != null ? registry.findPluginWithId( StepPluginType.class, this.stepid ).getSuggestion() : ""; break; } } }
public JobEntryCopy newJobEntry( JobMeta jobMeta, String type_desc, boolean openit ) { PluginRegistry registry = PluginRegistry.getInstance(); PluginInterface jobPlugin; jobPlugin = PluginRegistry.getInstance().findPluginWithName( JobEntryPluginType.class, type_desc ); if ( jobPlugin == null ) { jobPlugin = registry.findPluginWithId( JobEntryPluginType.class, JobMeta.STRING_SPECIAL ); JobEntryInterface jei = (JobEntryInterface) registry.loadClass( jobPlugin ); jei.setPluginId( jobPlugin.getIds()[0] ); jei.setName( entry_name );
public static final RepositoryRevisionBrowserDialogInterface getVersionBrowserDialog( Shell shell, Repository repository, final RepositoryElementInterface element ) throws Exception { String className = repository.getRepositoryMeta().getRevisionBrowserDialogClassName(); PluginRegistry registry = PluginRegistry.getInstance(); PluginInterface plugin = registry.getPlugin( RepositoryPluginType.class, repository.getRepositoryMeta().getId() ); Class<? extends RepositoryRevisionBrowserDialogInterface> dialogClass = registry.getClass( plugin, className ); Constructor<?> constructor = dialogClass.getConstructor( Shell.class, Integer.TYPE, Repository.class, RepositoryElementInterface.class ); return (RepositoryRevisionBrowserDialogInterface) constructor.newInstance( new Object[] { shell, Integer.valueOf( SWT.NONE ), repository, element, } ); } }
public static final String getMethod( String name ) { if ( Utils.isEmpty( name ) ) { return methodCodes[PARTITIONING_METHOD_NONE]; } for ( int i = 0; i < methodDescriptions.length; i++ ) { if ( methodDescriptions[i].equalsIgnoreCase( name ) ) { return methodCodes[i]; } } for ( int i = 0; i < methodCodes.length; i++ ) { if ( methodCodes[i].equalsIgnoreCase( name ) ) { return methodCodes[i]; } } PluginRegistry registry = PluginRegistry.getInstance(); PluginInterface plugin = registry.findPluginWithName( PartitionerPluginType.class, name ); if ( plugin != null ) { return name; } plugin = registry.findPluginWithId( PartitionerPluginType.class, name ); if ( plugin != null ) { return name; } return methodCodes[PARTITIONING_METHOD_NONE]; }
public DatabaseFactoryInterface getDatabaseFactory() throws Exception { PluginRegistry registry = PluginRegistry.getInstance(); PluginInterface plugin = registry.getPlugin( DatabasePluginType.class, databaseInterface.getPluginId() ); if ( plugin == null ) { throw new KettleDatabaseException( "database type with plugin id [" + databaseInterface.getPluginId() + "] couldn't be found!" ); } ClassLoader loader = registry.getClassLoader( plugin ); Class<?> clazz = Class.forName( databaseInterface.getDatabaseFactoryName(), true, loader ); return (DatabaseFactoryInterface) clazz.newInstance(); }
/** * Search for the right type of DatabaseInterface object and return it. * * @param databaseTypeDesc * the type of DatabaseInterface to look for (id or description) * @return The requested DatabaseInterface * * @throws KettleDatabaseException * when the type could not be found or referenced. */ private static final DatabaseInterface findDatabaseInterface( String databaseTypeDesc ) throws KettleDatabaseException { PluginRegistry registry = PluginRegistry.getInstance(); PluginInterface plugin = registry.getPlugin( DatabasePluginType.class, databaseTypeDesc ); if ( plugin == null ) { plugin = registry.findPluginWithName( DatabasePluginType.class, databaseTypeDesc ); } if ( plugin == null ) { throw new KettleDatabaseException( "database type with plugin id [" + databaseTypeDesc + "] couldn't be found!" ); } return getDatabaseInterfacesMap().get( plugin.getIds()[0] ); }
super.handlePluginAnnotation( clazz, annotation, libraries, nativePluginType, pluginFolder ); PluginInterface plugin = PluginRegistry.getInstance().findPluginWithId( ShimDependentJobEntryPluginType.class, ids[0] ); URL[] urls = new URL[libraries.size()]; for ( int i = 0; i < libraries.size(); i++ ) { classLoaderMap.put( librarySet, classloader ); PluginRegistry.getInstance().addClassLoader( classloader, plugin ); } catch ( ConfigurationException e ) { throw new KettlePluginException( e );