/** * Load and instantiate the main class of the plugin specified. * * @param plugin The plugin to load the main class for. * @return The instantiated class * @throws KettlePluginException In case there was a loading problem. */ public Object loadClass( PluginInterface plugin ) throws KettlePluginException { return loadClass( plugin, plugin.getMainType() ); }
public static List<ValueMetaInterface> getValueMetaPluginClasses() throws KettlePluginException { List<ValueMetaInterface> list = new ArrayList<ValueMetaInterface>(); List<PluginInterface> plugins = pluginRegistry.getPlugins( ValueMetaPluginType.class ); for ( PluginInterface plugin : plugins ) { ValueMetaInterface valueMetaInterface = (ValueMetaInterface) pluginRegistry.loadClass( plugin ); list.add( valueMetaInterface ); } return list; }
private Repository loadRepositoryObject( String id ) throws KettleException { Repository repository = pluginRegistry.loadClass( RepositoryPluginType.class, id, Repository.class ); if ( repository instanceof ReconnectableRepository ) { repository = wrapWithRepositoryTimeoutHandler( (ReconnectableRepository) repository ); } return repository; }
private Object loadPlugin( PluginInterface plugin ) { try { return PluginRegistry.getInstance().loadClass( plugin ); } catch ( KettlePluginException e ) { throw new RuntimeException( e ); } } }
private CartePluginInterface loadServlet( PluginInterface plugin ) throws KettlePluginException { return PluginRegistry.getInstance().loadClass( plugin, CartePluginInterface.class ); }
@Override public Collection<CompressionProvider> getCompressionProviders() { Collection<CompressionProvider> providerClasses = new ArrayList<CompressionProvider>(); List<PluginInterface> providers = getPlugins(); if ( providers != null ) { for ( PluginInterface plugin : providers ) { try { providerClasses.add( PluginRegistry.getInstance().loadClass( plugin, CompressionProvider.class ) ); } catch ( Exception e ) { // Do nothing here, if we can't load the provider, don't add it to the list } } } return providerClasses; }
private static void initLogginPlugins( List<PluginInterface> logginPlugins ) throws KettlePluginException { for ( PluginInterface plugin : logginPlugins ) { LoggingPluginInterface loggingPlugin = (LoggingPluginInterface) PluginRegistry.getInstance().loadClass( plugin ); loggingPlugin.init(); } }
@Override public String[] getCompressionProviderNames() { ArrayList<String> providerNames = new ArrayList<String>(); List<PluginInterface> providers = getPlugins(); if ( providers != null ) { for ( PluginInterface plugin : providers ) { try { CompressionProvider provider = PluginRegistry.getInstance().loadClass( plugin, CompressionProvider.class ); if ( provider != null ) { providerNames.add( provider.getName() ); } } catch ( Exception e ) { // Do nothing here, if we can't load the provider, don't add it to the list } } } return providerNames.toArray( new String[providerNames.size()] ); }
private KettleLifecycleListener createLifecycleListener() throws org.pentaho.di.core.exception.KettlePluginException { PluginInterface pluginInterface = mock( PluginInterface.class ); KettleLifecycleListener kettleLifecycleListener = mock( KettleLifecycleListener.class ); registeredPlugins.add( pluginInterface ); when( registry.loadClass( pluginInterface, KettleLifecycleListener.class ) ).thenReturn( kettleLifecycleListener ); when( registry.loadClass( pluginInterface ) ).thenReturn( kettleLifecycleListener ); if ( !typeListenerRegistration.getAllValues().isEmpty() ) { typeListenerRegistration.getValue().pluginAdded( pluginInterface ); } return kettleLifecycleListener; } }
@Override public ExtensionPointInterface get() { try { return registry.loadClass( extensionPointPlugin, ExtensionPointInterface.class ); } catch ( Exception e ) { getLog().logError( "Unable to load extension point for name = [" + ( extensionPointPlugin != null ? extensionPointPlugin.getName() : "null" ) + "]", e ); return null; } } }
public static ValueMetaInterface createValueMeta( String name, int type, int length, int precision ) throws KettlePluginException { PluginInterface stringPlugin = pluginRegistry.getPlugin( ValueMetaPluginType.class, String.valueOf( type ) ); if ( stringPlugin == null ) { throw new KettlePluginException( "Unable to locate value meta plugin of type (id) " + type ); } ValueMetaInterface valueMeta = pluginRegistry.loadClass( stringPlugin, ValueMetaInterface.class ); valueMeta.setName( name ); valueMeta.setLength( length, precision ); return valueMeta; }
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 ); } }
@Override public void run() { try { stepMeta.setRowDistribution( (RowDistributionInterface) PluginRegistry.getInstance().loadClass( rowDistributionPlugin ) ); } catch ( Exception e ) { LogChannel.GENERAL.logError( "Error loading row distribution plugin class: ", e ); } } };
public void pluginAdded( Object serviceObject ) { LifecycleListener listener = null; try { listener = (LifecycleListener) PluginRegistry.getInstance().loadClass( (PluginInterface) serviceObject ); } catch ( KettlePluginException e ) { e.printStackTrace(); return; } lifeListeners.add( listener ); if ( started ) { try { listener.onStart( handler ); } catch ( LifecycleException e ) { e.printStackTrace(); } } }
public void loadXML( Node rulesNode ) throws KettleException { List<Node> ruleNodes = XMLHandler.getNodes( rulesNode, BaseImportRule.XML_TAG ); for ( Node ruleNode : ruleNodes ) { String id = XMLHandler.getTagValue( ruleNode, "id" ); PluginRegistry registry = PluginRegistry.getInstance(); PluginInterface plugin = registry.findPluginWithId( ImportRulePluginType.class, id ); if ( plugin == null ) { throw new KettleException( "The import rule of type '" + id + "' could not be found in the plugin registry." ); } ImportRuleInterface rule = (ImportRuleInterface) registry.loadClass( plugin ); rule.loadXML( ruleNode ); getRules().add( rule ); } }
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(); }
private Repository openRepository( String repositoryName, String user, String pass ) throws KettleException { if ( Utils.isEmpty( repositoryName ) ) { return null; } RepositoriesMeta repositoriesMeta = new RepositoriesMeta(); repositoriesMeta.readData(); RepositoryMeta repositoryMeta = repositoriesMeta.findRepository( repositoryName ); if ( repositoryMeta == null ) { throw new KettleException( "Unable to find repository: " + repositoryName ); } PluginRegistry registry = PluginRegistry.getInstance(); Repository repository = registry.loadClass( RepositoryPluginType.class, repositoryMeta, Repository.class ); repository.init( repositoryMeta ); repository.connect( user, pass ); return repository; }
public Repository establishRepositoryConnection( RepositoryMeta repositoryMeta, final String username, final String password, final RepositoryOperation... operations ) throws KettleException, KettleSecurityException { Repository rep = PluginRegistry.getInstance().loadClass( RepositoryPluginType.class, repositoryMeta, Repository.class ); rep.init( repositoryMeta ); rep.getLog().setLogLevel( getLog().getLogLevel() ); rep.connect( username != null ? username : null, password != null ? password : null ); if ( operations != null ) { // throws KettleSecurityException if username does does have permission for given operations rep.getSecurityProvider().validateAction( operations ); } return rep; }
private Repository openRepository( String repositoryName, String user, String pass ) throws KettleException { if ( Utils.isEmpty( repositoryName ) ) { return null; } RepositoriesMeta repositoriesMeta = new RepositoriesMeta(); repositoriesMeta.readData(); RepositoryMeta repositoryMeta = repositoriesMeta.findRepository( repositoryName ); if ( repositoryMeta == null ) { throw new KettleException( "Unable to find repository: " + repositoryName ); } PluginRegistry registry = PluginRegistry.getInstance(); Repository repository = registry.loadClass( RepositoryPluginType.class, repositoryMeta, Repository.class ); repository.init( repositoryMeta ); repository.connect( user, pass ); return repository; }
public void loginToRepository() throws KettleException, KettleSecurityException { if ( model != null && model.getSelectedRepository() != null ) { RepositoryMeta repositoryMeta = input.getRepository( model.getRepositoryIndex( model.getSelectedRepository() ) ); repository = PluginRegistry.getInstance().loadClass( RepositoryPluginType.class, repositoryMeta.getId(), Repository.class ); repository.init( repositoryMeta ); repository.connect( model.getUsername(), model.getPassword() ); props.setLastRepository( repositoryMeta.getName() ); props.setLastRepositoryLogin( model.getUsername() ); } else { log.logDetailed( BaseMessages.getString( PKG, "RepositoryLogin.ErrorLoginToRepository" ) ); throw new KettleException( BaseMessages.getString( PKG, "RepositoryLogin.ErrorLoginToRepository" ) ); } }