Examples with PluginRegistry org.pentaho.di.core.plugins.PluginRegistry used on opensource projects

Example 96 with PluginRegistry

use of org.pentaho.di.core.plugins.PluginRegistry in project pentaho-kettle by pentaho.

the class SynchronizeAfterMergeIT method setUp.

@Before
public void setUp() throws KettleDatabaseException, SQLException {
    connection = DriverManager.getConnection("jdbc:h2:mem:PERSON;");
    connection.setAutoCommit(false);
    PreparedStatement stmt = connection.prepareStatement("CREATE TABLE PERSON (ID INT PRIMARY KEY, personName VARCHAR(64) )");
    stmt.execute();
    stmt.close();
    stmt = connection.prepareStatement("INSERT INTO PERSON (ID, personName) VALUES (?, ?)");
    for (int i = 0; i < ROW_FOR_UPDATE + ROW_FOR_DELETE; i++) {
        stmt.setInt(1, i);
        stmt.setString(2, "personName" + i);
        stmt.addBatch();
    }
    stmt.executeBatch();
    stmt.close();
    connection.commit();
    PluginRegistry pluginRegistry = PluginRegistry.getInstance();
    transMeta = new TransMeta();
    transMeta.setName("SynchronizeAfterMerge");
    InjectorMeta injectorMeta = new InjectorMeta();
    String injectorPid = pluginRegistry.getPluginId(StepPluginType.class, injectorMeta);
    StepMeta injectorStep = new StepMeta(injectorPid, injectorStepname, injectorMeta);
    transMeta.addStep(injectorStep);
    DatabaseMeta dbMeta = spy(new DatabaseMeta());
    dbMeta.setDatabaseType("H2");
    when(dbMeta.getURL()).thenReturn("jdbc:h2:mem:PERSON;");
    when(dbMeta.supportsErrorHandlingOnBatchUpdates()).thenReturn(false);
    SynchronizeAfterMergeMeta synchronizeAfterMergeMeta = new SynchronizeAfterMergeMeta();
    // set commit size
    synchronizeAfterMergeMeta.setCommitSize(COMMIT_SIZE);
    synchronizeAfterMergeMeta.setDatabaseMeta(dbMeta);
    synchronizeAfterMergeMeta.setKeyCondition(new String[] { "=" });
    synchronizeAfterMergeMeta.setKeyLookup(new String[] { "ID" });
    synchronizeAfterMergeMeta.setKeyStream(new String[] { "personName" });
    synchronizeAfterMergeMeta.setKeyStream2(new String[] { null });
    synchronizeAfterMergeMeta.setUpdate(new Boolean[] { Boolean.TRUE });
    synchronizeAfterMergeMeta.setOperationOrderField("flag");
    synchronizeAfterMergeMeta.setOrderDelete(DELETE_FLAG);
    synchronizeAfterMergeMeta.setOrderInsert(INSERT_FLAG);
    synchronizeAfterMergeMeta.setOrderUpdate(UPDATE_FLAG);
    synchronizeAfterMergeMeta.setPerformLookup(true);
    synchronizeAfterMergeMeta.setTableName("PERSON");
    synchronizeAfterMergeMeta.settablenameInField(false);
    synchronizeAfterMergeMeta.settablenameField(null);
    synchronizeAfterMergeMeta.setUseBatchUpdate(true);
    synchronizeAfterMergeMeta.setUpdateLookup(new String[] { "ID" });
    synchronizeAfterMergeMeta.setUpdateStream(new String[] { "personName" });
    String synchronizeAfterMergePid = pluginRegistry.getPluginId(StepPluginType.class, synchronizeAfterMergeStepname);
    StepMeta synchronizeAfterMerge = new StepMeta(synchronizeAfterMergePid, synchronizeAfterMergeStepname, synchronizeAfterMergeMeta);
    transMeta.addStep(synchronizeAfterMerge);
    String dummyResultStepName = "dummyResultStepName";
    DummyTransMeta dummyResultTransMeta = new DummyTransMeta();
    String dummyResultPid = pluginRegistry.getPluginId(StepPluginType.class, dummyResultTransMeta);
    StepMeta dummyResultStep = new StepMeta(dummyResultPid, dummyResultStepName, dummyResultTransMeta);
    transMeta.addStep(dummyResultStep);
    String dummyErrorStepName = "dummyErrorStepName";
    DummyTransMeta dummyErrorTransMeta = new DummyTransMeta();
    String dummyErrorPid = pluginRegistry.getPluginId(StepPluginType.class, dummyErrorTransMeta);
    StepMeta dummyErrorStep = new StepMeta(dummyErrorPid, dummyErrorStepName, dummyErrorTransMeta);
    transMeta.addStep(dummyErrorStep);
    StepErrorMeta stepErrorMeta = new StepErrorMeta(transMeta, synchronizeAfterMerge, dummyErrorStep);
    stepErrorMeta.setEnabled(true);
    synchronizeAfterMerge.setStepErrorMeta(stepErrorMeta);
    TransHopMeta injSynch = new TransHopMeta(injectorStep, synchronizeAfterMerge);
    transMeta.addTransHop(injSynch);
    TransHopMeta synchDummyResult = new TransHopMeta(synchronizeAfterMerge, dummyResultStep);
    transMeta.addTransHop(synchDummyResult);
    TransHopMeta synchDummyError = new TransHopMeta(synchronizeAfterMerge, dummyErrorStep);
    transMeta.addTransHop(synchDummyError);
}

Example 97 with PluginRegistry

use of org.pentaho.di.core.plugins.PluginRegistry in project pentaho-kettle by pentaho.

the class KettleEnvironment method init.

public static void init(List<PluginTypeInterface> pluginClasses, boolean simpleJndi) throws KettleException {
    SettableFuture<Boolean> ready;
    if (initialized.compareAndSet(null, ready = SettableFuture.create())) {
        try {
            // 
            if (!KettleClientEnvironment.isInitialized()) {
                KettleClientEnvironment.init();
            }
            // 
            if (simpleJndi) {
                JndiUtil.initJNDI();
            }
            // Register the native types and the plugins for the various plugin types...
            // 
            pluginClasses.forEach(PluginRegistry::addPluginType);
            PluginRegistry.init();
            // Also read the list of variables.
            // 
            KettleVariablesList.init();
            // Initialize the Lifecycle Listeners
            // 
            initLifecycleListeners();
            ready.set(true);
        } catch (Throwable t) {
            ready.setException(t);
            // If it's a KettleException, throw it, otherwise wrap it in a KettleException
            throw ((t instanceof KettleException) ? (KettleException) t : new KettleException(t));
        }
    } else {
        // A different thread is initializing
        ready = initialized.get();
        // Block until environment is initialized
        try {
            ready.get();
        } catch (Throwable t) {
            throw new KettleException(t);
        }
    }
}

Example 98 with PluginRegistry

use of org.pentaho.di.core.plugins.PluginRegistry in project pentaho-kettle by pentaho.

the class StringSearcher method findMetaData.

public static final void findMetaData(Object object, int level, List<StringSearchResult> stringList, Object parentObject, Object grandParentObject) {
    if ((object == null) || level > 5) {
        return;
    }
    PluginRegistry registry = PluginRegistry.getInstance();
    if (stepPluginPackages == null) {
        stepPluginPackages = registry.getPluginPackages(StepPluginType.class);
    }
    if (jobEntryPluginPackages == null) {
        jobEntryPluginPackages = registry.getPluginPackages(JobEntryPluginType.class);
    }
    Class<? extends Object> baseClass = object.getClass();
    Field[] fields = baseClass.getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
        Field field = fields[i];
        boolean processThisOne = true;
        if ((field.getModifiers() & Modifier.FINAL) > 0) {
            processThisOne = false;
        }
        if ((field.getModifiers() & Modifier.STATIC) > 0) {
            processThisOne = false;
        }
        // Investigate only if we're dealing with a sanctioned package.
        // A sanctioned package is either the local package (org.pentaho.di) or
        // a package of one of the plugins.
        // 
        boolean sanctionedPackage = false;
        String fieldToString = field.toString();
        if (fieldToString.indexOf(LOCAL_PACKAGE) >= 0) {
            sanctionedPackage = true;
        }
        for (int x = 0; x < JAVA_PACKAGES.length && !sanctionedPackage; x++) {
            if (fieldToString.indexOf(JAVA_PACKAGES[x]) >= 0) {
                sanctionedPackage = true;
            }
        }
        for (int x = 0; x < stepPluginPackages.size() && !sanctionedPackage; x++) {
            if (fieldToString.indexOf(stepPluginPackages.get(x)) >= 0) {
                sanctionedPackage = true;
            }
        }
        for (int x = 0; x < jobEntryPluginPackages.size() && !sanctionedPackage; x++) {
            if (fieldToString.indexOf(jobEntryPluginPackages.get(x)) >= 0) {
                sanctionedPackage = true;
            }
        }
        if (!sanctionedPackage) {
            // Stay in the sanctioned code-base.
            processThisOne = false;
        }
        // 
        if (processThisOne) {
            try {
                Object obj = field.get(object);
                if (obj != null) {
                    stringSearchInObject(obj, level, stringList, parentObject, grandParentObject, field);
                }
            } catch (IllegalAccessException e) {
                // OK, how do we get the value now?
                try {
                    Method method = findMethod(baseClass, field.getName());
                    if (method != null) {
                        // String fullMethod =
                        // baseClass.getName()+"."+method.getName()+"()";
                        Object string = method.invoke(object, (Object[]) null);
                        if (string != null) {
                            stringSearchInObject(string, level, stringList, parentObject, grandParentObject, field);
                        }
                    }
                } catch (Throwable ex) {
                // Ignore this error silently. If we can't access the method there
                // is nothing you can do about it.
                }
            }
        }
    }
}

Example 99 with PluginRegistry

use of org.pentaho.di.core.plugins.PluginRegistry in project pentaho-kettle by pentaho.

the class ImportRules method loadXML.

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);
    }
}

Example 100 with PluginRegistry

use of org.pentaho.di.core.plugins.PluginRegistry in project pentaho-kettle by pentaho.

the class MonetDBBulkLoaderMetaTest method setUp.

@Before
public void setUp() throws Exception {
    KettleEnvironment.init();
    PluginRegistry.init(false);
    TransMeta transMeta = new TransMeta();
    transMeta.setName("loader");
    lm = new MonetDBBulkLoaderMeta();
    ld = new MonetDBBulkLoaderData();
    PluginRegistry plugReg = PluginRegistry.getInstance();
    String loaderPid = plugReg.getPluginId(StepPluginType.class, lm);
    stepMeta = new StepMeta(loaderPid, "loader", lm);
    Trans trans = new Trans(transMeta);
    transMeta.addStep(stepMeta);
    loader = new MonetDBBulkLoader(stepMeta, ld, 1, transMeta, trans);
    List<String> attributes = Arrays.asList("dbConnectionName", "schemaName", "tableName", "logFile", "fieldSeparator", "fieldEnclosure", "NULLrepresentation", "encoding", "truncate", "fullyQuoteSQL", "fieldTable", "fieldStream", "fieldFormatOk");
    // Important note - the "databaseMeta" is not tested here as it's tied to the dbConnectionName. Since the loader
    // has assymetry here, we have to not test the databaseMeta, or we have to do surgery on the MonetDBBulkLoaderMeta
    // so that it's symmetric (and has no dependent variables like this).
    // MB -5/2016
    // Note - autoSchema is not persisted and neither is autoStringWidths. (Old functionality).
    FieldLoadSaveValidator<String[]> stringArrayLoadSaveValidator = new ArrayLoadSaveValidator<String>(new StringLoadSaveValidator(), 5);
    Map<String, FieldLoadSaveValidator<?>> attrValidatorMap = new HashMap<String, FieldLoadSaveValidator<?>>();
    attrValidatorMap.put("fieldTable", stringArrayLoadSaveValidator);
    attrValidatorMap.put("fieldStream", stringArrayLoadSaveValidator);
    attrValidatorMap.put("fieldFormatOk", new PrimitiveBooleanArrayLoadSaveValidator(new BooleanLoadSaveValidator(), 5));
    Map<String, FieldLoadSaveValidator<?>> typeValidatorMap = new HashMap<String, FieldLoadSaveValidator<?>>();
    loadSaveTester = new LoadSaveTester(testMetaClass, attributes, new ArrayList<String>(), new ArrayList<String>(), new HashMap<String, String>(), new HashMap<String, String>(), attrValidatorMap, typeValidatorMap, this);
}