Examples with LogChannelInterface org.pentaho.di.core.logging.LogChannelInterface used on opensource projects

Example 6 with LogChannelInterface

use of org.pentaho.di.core.logging.LogChannelInterface in project pentaho-kettle by pentaho.

the class Import method main.

public static void main(String[] a) throws KettleException {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    KettleEnvironment.init();
    Props.init(Props.TYPE_PROPERTIES_SPOON);
    List<String> args = pickupCmdArguments(a);
    StringBuilder optionRepname, optionUsername, optionPassword, optionDirname;
    StringBuilder optionLimitDir, optionFilename, optionRules, optionComment;
    StringBuilder optionReplace, optionContinueOnError, optionVersion, optionFileDir, optionNoRules;
    CommandLineOption[] options = new CommandLineOption[] { // 
    createOption("rep", "Import.CmdLine.RepName", optionRepname = new StringBuilder()), createOption("user", "Import.CmdLine.RepUsername", optionUsername = new StringBuilder()), createOption("pass", "Import.CmdLine.RepPassword", optionPassword = new StringBuilder()), createOption("dir", "Import.CmdLine.RepDir", optionDirname = new StringBuilder()), createOption("limitdir", "Import.CmdLine.LimitDir", optionLimitDir = new StringBuilder()), createOption("file", "Import.CmdLine.File", optionFilename = new StringBuilder()), createOption("filedir", "Import.CmdLine.FileDir", optionFileDir = new StringBuilder()), createOption("rules", "Import.CmdLine.RulesFile", optionRules = new StringBuilder()), createOption("norules", "Import.CmdLine.NoRules", optionNoRules = new StringBuilder(), true, false), createOption("comment", "Import.CmdLine.Comment", optionComment = new StringBuilder(), false, false), createOption("replace", "Import.CmdLine.Replace", optionReplace = new StringBuilder(), true, false), createOption("coe", "Import.CmdLine.ContinueOnError", optionContinueOnError = new StringBuilder(), true, false), createOption("version", "Import.CmdLine.Version", optionVersion = new StringBuilder(), true, false), new CommandLineOption("", BaseMessages.getString(PKG, "Import.CmdLine.ExtraFiles"), new StringBuilder(), false, true, true) };
    if (args.isEmpty()) {
        CommandLineOption.printUsage(options);
        exitJVM(9);
    }
    final LogChannelInterface log = new LogChannel(STRING_IMPORT);
    CommandLineOption.parseArguments(args, options, log);
    // The arguments that are still left in args are in fact filenames that need to be imported.
    // This list is otherwise empty.
    // To that we add the normal filename option
    // 
    List<String> filenames = new ArrayList<String>(args);
    if (!Utils.isEmpty(optionFilename)) {
        filenames.add(optionFilename.toString());
    }
    String kettleRepname = Const.getEnvironmentVariable("KETTLE_REPOSITORY", null);
    String kettleUsername = Const.getEnvironmentVariable("KETTLE_USER", null);
    String kettlePassword = Const.getEnvironmentVariable("KETTLE_PASSWORD", null);
    if (!Utils.isEmpty(kettleRepname)) {
        optionRepname = new StringBuilder(kettleRepname);
    }
    if (!Utils.isEmpty(kettleUsername)) {
        optionUsername = new StringBuilder(kettleUsername);
    }
    if (!Utils.isEmpty(kettlePassword)) {
        optionPassword = new StringBuilder(kettlePassword);
    }
    if (!Utils.isEmpty(optionVersion)) {
        BuildVersion buildVersion = BuildVersion.getInstance();
        log.logBasic(BaseMessages.getString(PKG, "Import.Log.KettleVersion", buildVersion.getVersion(), buildVersion.getRevision(), buildVersion.getBuildDate()));
        if (a.length == 1) {
            exitJVM(6);
        }
    }
    // 
    if (Utils.isEmpty(optionRepname)) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.NoRepProvided"));
        exitJVM(1);
    }
    if (Utils.isEmpty(filenames)) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.NoExportFileProvided"));
        exitJVM(1);
    }
    if (Utils.isEmpty(optionDirname)) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.NoRepositoryDirectoryProvided"));
        exitJVM(1);
    }
    if (Utils.isEmpty(optionRules) && Utils.isEmpty(optionNoRules) && !"Y".equalsIgnoreCase(optionNoRules.toString())) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.NoRulesFileProvided"));
        exitJVM(1);
    }
    // Load the rules file!
    // 
    ImportRules importRules = new ImportRules();
    String rulesFile = optionRules.toString();
    if (!Utils.isEmpty(rulesFile)) {
        try {
            Document document = XMLHandler.loadXMLFile(rulesFile);
            Node rulesNode = XMLHandler.getSubNode(document, ImportRules.XML_TAG);
            importRules.loadXML(rulesNode);
            log.logMinimal(BaseMessages.getString(PKG, "Import.Log.RulesLoaded", rulesFile, Integer.toString(importRules.getRules().size())));
            for (ImportRuleInterface rule : importRules.getRules()) {
                log.logBasic(" - " + rule.toString());
            }
        } catch (KettleException e) {
            log.logError(BaseMessages.getString(PKG, "Import.Log.ExceptionLoadingRules", rulesFile), e);
            exitJVM(7);
        }
    }
    // Get the list of limiting source directories
    // 
    List<String> limitDirs;
    if (!Utils.isEmpty(optionLimitDir)) {
        String[] directories = optionLimitDir.toString().split(",");
        limitDirs = Arrays.asList(directories);
    } else {
        limitDirs = Collections.emptyList();
    }
    // Find the repository metadata...
    // 
    RepositoriesMeta repsinfo = new RepositoriesMeta();
    repsinfo.getLog().setLogLevel(log.getLogLevel());
    try {
        repsinfo.readData();
    } catch (Exception e) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.UnableToLoadRepositoryInformation"), e);
        exitJVM(1);
    }
    RepositoryMeta repositoryMeta = repsinfo.findRepository(optionRepname.toString());
    if (repositoryMeta == null) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.RepositoryCouldNotBeFound", optionRepname.toString()));
        exitJVM(1);
    }
    if (Utils.isEmpty(optionRepname)) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.NoRepProvided"));
        exitJVM(1);
    }
    // Load the repository object as a plugin...
    // 
    Repository repository = null;
    try {
        repository = PluginRegistry.getInstance().loadClass(RepositoryPluginType.class, repositoryMeta, Repository.class);
        repository.init(repositoryMeta);
        repository.getLog().setLogLevel(log.getLogLevel());
    } catch (Exception e) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.UnableToLoadOrInitializeRepository"));
        exitJVM(1);
    }
    try {
        repository.connect(optionUsername != null ? optionUsername.toString() : null, optionPassword != null ? optionPassword.toString() : null);
    } catch (KettleException ke) {
        log.logError(ke.getMessage());
        exitJVM(1);
    } catch (Exception e) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.UnableToConnectToRepository"));
        exitJVM(1);
    }
    final boolean replace = Utils.isEmpty(optionReplace) ? false : ValueMetaString.convertStringToBoolean(optionReplace.toString());
    final boolean continueOnError = Utils.isEmpty(optionContinueOnError) ? false : ValueMetaString.convertStringToBoolean(optionContinueOnError.toString());
    // Start the import!
    // 
    log.logMinimal(BaseMessages.getString(PKG, "Import.Log.Starting"));
    Date start, stop;
    SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
    start = new Date();
    int returnCode = 0;
    if (ROOT_DIRECTORY.equals(optionDirname.toString())) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.TargetDirectoryIsRootDirectory"));
        exitJVM(1);
    }
    try {
        RepositoryDirectoryInterface tree = repository.loadRepositoryDirectoryTree();
        RepositoryDirectoryInterface targetDirectory = tree.findDirectory(optionDirname.toString());
        if (targetDirectory == null) {
            log.logError(BaseMessages.getString(PKG, "Import.Error.UnableToFindTargetDirectoryInRepository", optionDirname.toString()));
            exitJVM(1);
        }
        // Perform the actual import
        IRepositoryImporter importer = repository.getImporter();
        importer.setImportRules(importRules);
        if (!limitDirs.isEmpty()) {
            if (importer instanceof CanLimitDirs) {
                ((CanLimitDirs) importer).setLimitDirs(limitDirs);
            } else {
                throw new KettleException(BaseMessages.getString(PKG, "Import.CouldntLimitDirs", importer.getClass().getCanonicalName()));
            }
        }
        RepositoryImportFeedbackInterface feedbackInterface = new ImportFeedback(log, continueOnError, replace, reader);
        // Import files in a certain directory
        importer.importAll(feedbackInterface, optionFileDir.toString(), filenames.toArray(new String[filenames.size()]), targetDirectory, replace, continueOnError, optionComment.toString());
        // If the importer has exceptions, then our return code is 2
        List<Exception> exceptions = importer.getExceptions();
        if (exceptions != null && !exceptions.isEmpty()) {
            log.logError(BaseMessages.getString(PKG, "Import.Error.UnexpectedErrorDuringImport"), exceptions.get(0));
            returnCode = 2;
        }
    } catch (Exception e) {
        log.logError(BaseMessages.getString(PKG, "Import.Error.UnexpectedErrorDuringImport"), e);
        exitJVM(2);
    }
    log.logMinimal(BaseMessages.getString(PKG, "Import.Log.Finished"));
    stop = new Date();
    String begin = df.format(start);
    String end = df.format(stop);
    log.logMinimal(BaseMessages.getString(PKG, "Import.Log.StartStop", begin, end));
    long seconds = (stop.getTime() - start.getTime()) / 1000;
    if (seconds <= 60) {
        log.logMinimal(BaseMessages.getString(PKG, "Import.Log.ProcessEndAfter", String.valueOf(seconds)));
    } else if (seconds <= 60 * 60) {
        int min = (int) (seconds / 60);
        int rem = (int) (seconds % 60);
        log.logMinimal(BaseMessages.getString(PKG, "Import.Log.ProcessEndAfterLong", String.valueOf(min), String.valueOf(rem), String.valueOf(seconds)));
    } else if (seconds <= 60 * 60 * 24) {
        int rem;
        int hour = (int) (seconds / (60 * 60));
        rem = (int) (seconds % (60 * 60));
        int min = rem / 60;
        rem = rem % 60;
        log.logMinimal(BaseMessages.getString(PKG, "Import.Log.ProcessEndAfterLonger", String.valueOf(hour), String.valueOf(min), String.valueOf(rem), String.valueOf(seconds)));
    } else {
        int rem;
        int days = (int) (seconds / (60 * 60 * 24));
        rem = (int) (seconds % (60 * 60 * 24));
        int hour = rem / (60 * 60);
        rem = rem % (60 * 60);
        int min = rem / 60;
        rem = rem % 60;
        log.logMinimal(BaseMessages.getString(PKG, "Import.Log.ProcessEndAfterLongest", String.valueOf(days), String.valueOf(hour), String.valueOf(min), String.valueOf(rem), String.valueOf(seconds)));
    }
    exitJVM(returnCode);
}

Example 7 with LogChannelInterface

use of org.pentaho.di.core.logging.LogChannelInterface in project pentaho-kettle by pentaho.

the class ExtensionPointIntegrationTest method test.

@Test
public void test() throws Exception {
    // check that all extension points are added to the map
    assertEquals(KettleExtensionPoint.values().length, ExtensionPointMap.getInstance().getNumberOfRows());
    // check that all extension points are executed
    final LogChannelInterface log = mock(LogChannelInterface.class);
    for (KettleExtensionPoint ep : KettleExtensionPoint.values()) {
        final ExtensionPointInterface currentEP = ExtensionPointMap.getInstance().getTableValue(ep.id, "id" + ep.id);
        assertFalse(currentEP.getClass().getField(EXECUTED_FIELD_NAME).getBoolean(currentEP));
        ExtensionPointHandler.callExtensionPoint(log, ep.id, null);
        assertTrue(currentEP.getClass().getField(EXECUTED_FIELD_NAME).getBoolean(currentEP));
    }
    // check modification of extension point
    final KettleExtensionPoint jobAfterOpen = KettleExtensionPoint.JobAfterOpen;
    final ExtensionPointInterface int1 = ExtensionPointMap.getInstance().getTableValue(jobAfterOpen.id, "id" + jobAfterOpen.id);
    ExtensionPointPluginType.getInstance().registerCustom(createClassRuntime(jobAfterOpen, "Edited"), "custom", "id" + jobAfterOpen.id, jobAfterOpen.id, "no description", null);
    assertNotSame(int1, ExtensionPointMap.getInstance().getTableValue(jobAfterOpen.id, "id" + jobAfterOpen.id));
    assertEquals(KettleExtensionPoint.values().length, ExtensionPointMap.getInstance().getNumberOfRows());
    // check removal of extension point
    PluginRegistry.getInstance().removePlugin(ExtensionPointPluginType.class, PluginRegistry.getInstance().getPlugin(ExtensionPointPluginType.class, "id" + jobAfterOpen.id));
    assertTrue(ExtensionPointMap.getInstance().getTableValue(jobAfterOpen.id, "id" + jobAfterOpen.id) == null);
    assertEquals(KettleExtensionPoint.values().length - 1, ExtensionPointMap.getInstance().getNumberOfRows());
}

Example 8 with LogChannelInterface

use of org.pentaho.di.core.logging.LogChannelInterface in project pentaho-kettle by pentaho.

the class ExtensionPointIntegrationTest method testExtensionPointMapConcurrency.

@Test
public void testExtensionPointMapConcurrency() throws InterruptedException {
    final LogChannelInterface log = mock(LogChannelInterface.class);
    List<Runnable> parallelTasksList = new ArrayList<>(TOTAL_THREADS_TO_RUN);
    for (int i = 0; i < TOTAL_THREADS_TO_RUN; i++) {
        parallelTasksList.add(() -> {
            KettleExtensionPoint kettleExtensionPoint = getRandomKettleExtensionPoint();
            PluginInterface pluginInterface = PluginRegistry.getInstance().getPlugin(ExtensionPointPluginType.class, "id" + kettleExtensionPoint.id);
            try {
                PluginRegistry.getInstance().removePlugin(ExtensionPointPluginType.class, pluginInterface);
                PluginRegistry.getInstance().registerPlugin(ExtensionPointPluginType.class, pluginInterface);
            } catch (KettlePluginException e) {
                e.printStackTrace();
            } catch (NullPointerException e) {
            // NullPointerException can be thrown if trying to remove a plugin that doesn't exit, discarding occurence
            }
            ExtensionPointMap.getInstance().reInitialize();
            try {
                ExtensionPointMap.getInstance().callExtensionPoint(log, kettleExtensionPoint.id, null);
            } catch (KettleException e) {
                e.printStackTrace();
            }
        });
    }
    assertConcurrent(parallelTasksList);
}

Example 9 with LogChannelInterface

use of org.pentaho.di.core.logging.LogChannelInterface in project pentaho-kettle by pentaho.

the class SalesforceConnectionIT method testConnectOptions.

@Test
public void testConnectOptions() {
    LogChannelInterface logInterface = mock(LogChannelInterface.class);
    String url = SalesforceConnectionUtils.TARGET_DEFAULT_URL;
    String username = "username";
    String password = "password";
    Integer timeout = 30;
    try {
        SalesforceConnection connection = spy(new SalesforceConnection(logInterface, url, username, password));
        connection.setTimeOut(timeout);
        LoginResult loginResult = mock(LoginResult.class);
        GetUserInfoResult userInfo = mock(GetUserInfoResult.class);
        GetServerTimestampResult serverTime = new GetServerTimestampResult();
        serverTime.setTimestamp(Calendar.getInstance());
        ArgumentCaptor<ConnectorConfig> captorConfig = ArgumentCaptor.forClass(ConnectorConfig.class);
        doReturn(loginResult).when(bindingStub).login(anyString(), anyString());
        doReturn(userInfo).when(bindingStub).getUserInfo();
        when(loginResult.getServerUrl()).thenReturn("http://localhost/services/Soap/u/37.0");
        when(loginResult.getSessionId()).thenReturn(UUID.randomUUID().toString());
        when(userInfo.getUserFullName()).thenReturn(UUID.randomUUID().toString());
        when(userInfo.getUserEmail()).thenReturn(UUID.randomUUID().toString());
        when(userInfo.getUserLanguage()).thenReturn(UUID.randomUUID().toString());
        when(userInfo.getOrganizationName()).thenReturn(UUID.randomUUID().toString());
        doReturn(serverTime).when(bindingStub).getServerTimestamp();
        connection.setTimeOut(timeout);
        connection.setUsingCompression(true);
        connection.setRollbackAllChangesOnError(true);
        try {
            connection.connect();
        } catch (KettleException e) {
        // The connection should fail
        // We just want to see the generated ConnectorConfig
        }
        verify(connection).createBinding(captorConfig.capture());
        ConnectorConfig config = captorConfig.getValue();
        assertNotNull(config);
        assertEquals(url, config.getAuthEndpoint());
        assertTrue(config.isCompression());
        assertTrue(config.isManualLogin());
        assertEquals(timeout, Integer.valueOf(config.getConnectionTimeout()));
        assertEquals(timeout, Integer.valueOf(config.getReadTimeout()));
    } catch (Exception e) {
        fail("Connection fail: " + e.getMessage());
    }
}

Example 10 with LogChannelInterface

use of org.pentaho.di.core.logging.LogChannelInterface in project pentaho-kettle by pentaho.

the class RepositoryImporterTest method testPatchTransSteps_with_meta_inject_step.

@Test
public void testPatchTransSteps_with_meta_inject_step() throws Exception {
    Repository repository = mock(Repository.class);
    LogChannelInterface log = mock(LogChannelInterface.class);
    RepositoryImporter importer = spy(new RepositoryImporter(repository, log));
    importer.setBaseDirectory(mock(RepositoryDirectoryInterface.class));
    doReturn("TEST_PATH").when(importer).resolvePath(anyString(), anyString());
    MetaInjectMeta metaInjectMeta = mock(MetaInjectMeta.class);
    doReturn(ObjectLocationSpecificationMethod.REPOSITORY_BY_NAME).when(metaInjectMeta).getSpecificationMethod();
    StepMeta stepMeta = mock(StepMeta.class);
    doReturn(metaInjectMeta).when(stepMeta).getStepMetaInterface();
    doReturn(true).when(stepMeta).isEtlMetaInject();
    TransMeta transMeta = mock(TransMeta.class);
    doReturn(Collections.singletonList(stepMeta)).when(transMeta).getSteps();
    Object[] object = new Object[4];
    object[0] = "TEST_PATH";
    object[1] = mock(RepositoryDirectoryInterface.class);
    object[2] = stepMeta;
    object[3] = true;
    RepositoryImporterExtension repositoryImporterExtension = new RepositoryImporterExtension();
    repositoryImporterExtension.callExtensionPoint(log, object);
    verify(metaInjectMeta).setDirectoryPath("TEST_PATH");
}