org.pentaho.di.core.parameters.UnknownParamException Java Examples

private void updateTransformationParameter( final FormulaContext formulaContext,
                                            final Trans trans )
  throws UnknownParamException, EvaluationException, ParseException {
  for ( int i = 0; i < this.parameter.length; i++ ) {
    final FormulaParameter mapping = this.parameter[ i ];
    final String sourceName = mapping.getName();
    final Object value = mapping.compute( formulaContext );
    TransMeta transMeta = trans.getTransMeta();
    if ( value != null ) {
      String paramValue = String.valueOf( value );
      trans.setParameterValue( sourceName, paramValue );
      transMeta.setParameterValue( sourceName, paramValue );
    } else {
      trans.setParameterValue( sourceName, null );
      transMeta.setParameterValue( sourceName, null );
    }
    trans.setTransMeta( transMeta );
  }
}
 

@Test
@SuppressWarnings( "ResultOfMethodCallIgnored" )
public void testBuildSchedulerRequestEntity() throws UnknownParamException, UnsupportedEncodingException {
  AbstractMeta meta = mock( JobMeta.class );
  RepositoryDirectoryInterface repositoryDirectory = mock( RepositoryDirectoryInterface.class );

  doReturn( repositoryDirectory ).when( meta ).getRepositoryDirectory();
  doReturn( TEST_REPOSITORY_DIRECTORY ).when( repositoryDirectory ).getPath();
  doReturn( TEST_JOB_NAME ).when( meta ).getName();
  doReturn( JOB_EXTENSION ).when( meta ).getDefaultExtension();

  doReturn( LogLevel.getLogLevelForCode( TEST_LOG_LEVEL_PARAM_VALUE ) ).when( meta ).getLogLevel();
  doReturn( Boolean.valueOf( TEST_CLEAR_LOG_PARAM_VALUE ) ).when( meta ).isClearingLog();
  doReturn( Boolean.valueOf( TEST_RUN_SAFE_MODE_PARAM_VALUE ) ).when( meta ).isSafeModeEnabled();
  doReturn( Boolean.valueOf( TEST_GATHERING_METRICS_PARAM_VALUE ) ).when( meta ).isGatheringMetrics();
  doReturn( TEST_START_COPY_NAME_PARAM_VALUE ).when( (JobMeta) meta ).getStartCopyName();
  doReturn( Boolean.valueOf( TEST_EXPANDING_REMOTE_JOB_PARAM_VALUE ) ).when( (JobMeta) meta ).isExpandingRemoteJob();

  doReturn( ARRAY_WITH_TEST_PDI_PARAM_NAME ).when( meta ).listParameters();
  doReturn( TEST_PDI_PARAM_VALUE ).when( meta ).getParameterValue( TEST_PDI_PARAM_NAME );

  doCallRealMethod().when( schedulerRequest ).buildSchedulerRequestEntity( meta );

  assertTrue( compareContentOfStringEntities( schedulerRequest.buildSchedulerRequestEntity( meta ),
          new StringEntity( REFERENCE_TEST_REQUEST ) ) );
}
 

/**
 * Configures the transformation with the given parameters and their values
 *
 * @param trans        the executable transformation object
 * @param optionParams the list of parameters to set for the transformation
 * @param transMeta    the transformation metadata
 * @throws UnknownParamException
 */
protected static void configureParameters( Trans trans, NamedParams optionParams,
                                             TransMeta transMeta ) throws UnknownParamException {
  trans.initializeVariablesFrom( null );
  trans.getTransMeta().setInternalKettleVariables( trans );

  // Map the command line named parameters to the actual named parameters.
  // Skip for the moment any extra command line parameter not known in the transformation.
  String[] transParams = trans.listParameters();
  for ( String param : transParams ) {
    String value = optionParams.getParameterValue( param );
    if ( value != null ) {
      trans.setParameterValue( param, value );
      transMeta.setParameterValue( param, value );
    }
  }

  // Put the parameters over the already defined variable space. Parameters get priority.
  trans.activateParameters();
}
 

public boolean isSuppressResultData() {
  boolean returnVal = suppressResultData;
  if ( !suppressResultData && parentJobMeta != null ) {
    String[] params = parentJobMeta.listParameters();
    for ( String param : params ) {
      if ( param.startsWith( "SUPPRESS_TRANS_RESULT_DATA_" ) ) {
        try {
          String paramVal = parentJobMeta.getParameterValue( param );
          if ( paramVal != null ) {
            returnVal |= paramVal.equals( this.getName() );
          }
        } catch ( UnknownParamException e ) {
          logError( BaseMessages.getString( PKG, "JobTrans.Exception.SuppressResultParam" ), e );
        }
      }
    }
  }
  return returnVal;
}
 

private void copyJobParameters( Job job, Map<String, String> params ) throws UnknownParamException {
  JobMeta jobMeta = job.getJobMeta();
  // Also copy the parameters over...
  job.copyParametersFrom( jobMeta );
  job.clearParameters();
  String[] parameterNames = job.listParameters();
  for ( String parameterName : parameterNames ) {
    // Grab the parameter value set in the job entry
    String thisValue = params.get( parameterName );
    if ( !StringUtils.isBlank( thisValue ) ) {
      // Set the value as specified by the user in the job entry
      jobMeta.setParameterValue( parameterName, thisValue );
    }
  }
  jobMeta.activateParameters();
}
 

private void setVariablesInTransformation( BeamJobConfig config, TransMeta transMeta ) {
  String[] parameters = transMeta.listParameters();
  for ( JobParameter parameter : config.getParameters() ) {
    if ( StringUtils.isNotEmpty( parameter.getVariable() ) ) {
      if ( Const.indexOfString( parameter.getVariable(), parameters ) >= 0 ) {
        try {
          transMeta.setParameterValue( parameter.getVariable(), parameter.getValue() );
        } catch ( UnknownParamException e ) {
          transMeta.setVariable( parameter.getVariable(), parameter.getValue() );
        }
      } else {
        transMeta.setVariable( parameter.getVariable(), parameter.getValue() );
      }
    }
  }
  transMeta.activateParameters();
}
 

@Override
public Map<String, String> getParams() {
  if ( this.namedParams == null ) {
    return Collections.EMPTY_MAP;
  }

  Map<String, String> params = new HashMap<String, String>();

  for ( String key : this.namedParams.listParameters() ) {
    try {
      params.put( key, this.namedParams.getParameterValue( key ) );
    } catch ( UnknownParamException e ) {
      /* no-op */
    }
  }

  return params;
}
 

@Override
public Map<String, String> getCustomParams() {
  if ( this.customNamedParams == null ) {
    return Collections.EMPTY_MAP;
  }

  Map<String, String> customParams = new HashMap<String, String>();

  for ( String key : this.customNamedParams.listParameters() ) {
    try {
      customParams.put( key, this.customNamedParams.getParameterValue( key ) );
    } catch ( UnknownParamException e ) {
      /* no-op */
    }
  }

  return customParams;
}
 

protected JobMeta getJobMeta( String resource ) throws KettleXMLException, URISyntaxException, IOException,
  UnknownParamException {
  JobMeta jobMeta = new JobMeta( getCanonicalPath( resource ), null );
  /*
   * jobMeta.setParameterValue( "junit.name", TMP ); jobMeta.setParameterValue( "junit.user", USER );
   * jobMeta.setParameterValue( "junit.password", USER );
   */
  return jobMeta;
}
 

@Test
public void testPrepareFieldNamesParameters() throws UnknownParamException {
  // array of params
  String[] parameterNames = new String[2];
  parameterNames[0] = "param1";
  parameterNames[1] = "param2";

  // array of fieldNames params
  String[] parameterFieldNames = new String[1];
  parameterFieldNames[0] = "StreamParam1";

  // array of parameterValues params
  String[] parameterValues = new String[2];
  parameterValues[1] = "ValueParam2";


  JobEntryTrans jet = new JobEntryTrans();
  VariableSpace variableSpace = new Variables();
  jet.copyVariablesFrom( variableSpace );

  //at this point StreamColumnNameParams are already inserted in namedParams
  NamedParams namedParam = Mockito.mock( NamedParamsDefault.class );
  Mockito.doReturn( "value1" ).when( namedParam ).getParameterValue(  "param1" );
  Mockito.doReturn( "value2" ).when( namedParam ).getParameterValue(  "param2" );

  jet.prepareFieldNamesParameters( parameterNames, parameterFieldNames, parameterValues, namedParam, jet );

  Assert.assertEquals( "value1", jet.getVariable( "param1" ) );
  Assert.assertEquals( null, jet.getVariable( "param2" ) );
}
 

protected void printTransformationParameters( Trans trans ) throws UnknownParamException {

    if ( trans != null && trans.listParameters() != null ) {

      for ( String pName : trans.listParameters() ) {
        printParameter( pName, trans.getParameterValue( pName ), trans.getParameterDefault( pName ), trans.getParameterDescription( pName ) );
      }
    }
  }
 

@Test
public void testJobTracker() throws UnknownParamException, KettleXMLException, URISyntaxException, IOException {
  if ( res.setAsVariable != null ) {
    System.getProperties().setProperty( DatabaseLogExceptionFactory.KETTLE_GLOBAL_PROP_NAME,
        res.setAsVariable.toString() );
  }

  try {
    Job job = new Job( null, getJobMeta( res.fileName ) );
    job.setLogLevel( LogLevel.BASIC );
    job.start();
    job.waitUntilFinished();

    // this simulates - Spoon 'Job Metrics' tab attempt to refresh:
    JobTracker tracker = job.getJobTracker();
    List<JobTracker> trackers = tracker.getJobTrackers();
    Assert.assertEquals( "Job trackers count is correct: " + res.assertMessage, res.jobTrackerStatus.length, trackers
        .size() );

    for ( int i = 0; i < res.jobTrackerStatus.length; i++ ) {
      JobTracker record = trackers.get( i );
      Boolean actual;
      JobEntryResult jer = record.getJobEntryResult();
      // don't look into nested JobTrackers
      if ( jer == null ) {
        actual = null;
      } else {
        actual =
            record.getJobEntryResult().getResult() == null ? null : Boolean.valueOf( record.getJobEntryResult()
                .getResult().getResult() );
      }
      Assert.assertEquals( res.assertMessage + ": " + i, res.jobTrackerStatus[i], actual );
    }
  } finally {
    System.getProperties().remove( DatabaseLogExceptionFactory.KETTLE_GLOBAL_PROP_NAME );
  }
}
 

protected void printJobParameters( Job job ) throws UnknownParamException {

    if ( job != null && job.listParameters() != null ) {

      for ( String pName : job.listParameters() ) {
        printParameter( pName, job.getParameterValue( pName ), job.getParameterDefault( pName ), job.getParameterDescription( pName ) );
      }
    }
  }
 

public void prepareFieldNamesParameters( String[] parameters, String[] parameterFieldNames, String[] parameterValues,
                                                  NamedParams namedParam, JobEntryTrans jobEntryTrans )
  throws UnknownParamException {
  for ( int idx = 0; idx < parameters.length; idx++ ) {
    // Grab the parameter value set in the Trans job entry
    // Set fieldNameParameter only if exists and if it is not declared any staticValue( parameterValues array )
    //
    String thisValue = namedParam.getParameterValue( parameters[ idx ] );
    // multiple executions on the same jobEntryTrans variableSpace need to be updated even for nulls or blank values.
    // so we have to ask if that same variable had a value before and if it had - and the new value is empty -
    // we should set it as a blank value instead of ignoring it.
    // NOTE: we should only replace it if we have a parameterFieldNames defined -> parameterFieldNames[ idx ] ) != null
    if ( !Utils.isEmpty( jobEntryTrans.getVariable( parameters[ idx ] ) ) && Utils.isEmpty( thisValue )
      && idx < parameterFieldNames.length && !Utils.isEmpty( Const.trim( parameterFieldNames[ idx ] ) ) ) {
      jobEntryTrans.setVariable( parameters[ idx ], "" );
    }
    // Set value only if is not empty at namedParam and exists in parameterFieldNames
    if ( !Utils.isEmpty( thisValue ) && idx < parameterFieldNames.length ) {
      // If exists then ask if is not empty
      if ( !Utils.isEmpty( Const.trim( parameterFieldNames[ idx ] ) ) ) {
        // If is not empty then we have to ask if it exists too in parameterValues array, since the values in
        // parameterValues prevail over parameterFieldNames
        if ( idx < parameterValues.length ) {
          // If is empty at parameterValues array, then we can finally add that variable with that value
          if ( Utils.isEmpty( Const.trim( parameterValues[ idx ] ) ) ) {
            jobEntryTrans.setVariable( parameters[ idx ], thisValue );
          }
        } else {
          // Or if not in parameterValues then we can add that variable with that value too
          jobEntryTrans.setVariable( parameters[ idx ], thisValue );
        }
      }
    }
  }
}
 

private void copyParameters( final AbstractMeta meta, final Map<String, String> params  ) throws UnknownParamException {
  for ( Map.Entry<String, String> entry : params.entrySet() ) {
    String thisValue = entry.getValue();
    if ( !StringUtils.isBlank( thisValue ) ) {
      meta.setParameterValue( entry.getKey(), thisValue );
    }
  }
}
 

@Override public String getParameterValue( String key ) throws UnknownParamException {
  return namedParams.getParameterValue( key );
}
 

@Override public void setParameterValue( String key, String value ) throws UnknownParamException {
  namedParams.setParameterValue( key, value );
}
 

@Override public String getParameterDefault( String key ) throws UnknownParamException {
  return namedParams.getParameterDefault( key );
}
 

@Override public String getParameterDescription( String key ) throws UnknownParamException {
  return namedParams.getParameterDescription( key );
}
 

@Override
public void setParameterValue( String key, String value ) throws UnknownParamException {
  namedParams.setParameterValue( key, value );
}
 

@Override
public String getParameterValue( String key ) throws UnknownParamException {
  return namedParams.getParameterValue( key );
}
 

@Override
public String getParameterDefault( String key ) throws UnknownParamException {
  return namedParams.getParameterDefault( key );
}
 

@Test
public void testPrepareFieldNamesParametersWithNulls() throws UnknownParamException {
  //NOTE: this only tests the prepareFieldNamesParameters function not all variable substitution logic
  // array of params
  String[] parameterNames = new String[7];
  parameterNames[0] = "param1";
  parameterNames[1] = "param2";
  parameterNames[2] = "param3";
  parameterNames[3] = "param4";
  parameterNames[4] = "param5";
  parameterNames[5] = "param6";
  parameterNames[6] = "param7";

  // array of fieldNames params
  String[] parameterFieldNames = new String[7];
  parameterFieldNames[0] = null;
  parameterFieldNames[2] = "ValueParam3";
  parameterFieldNames[3] = "FieldValueParam4";
  parameterFieldNames[4] = "FieldValueParam5";
  parameterFieldNames[6] = "FieldValueParam7";

  // array of parameterValues params
  String[] parameterValues = new String[7];
  parameterValues[1] = "ValueParam2";
  parameterValues[3] = "";
  parameterValues[4] = "StaticValueParam5";
  parameterValues[5] = "StaticValueParam6";


  JobEntryTrans jet = new JobEntryTrans();
  VariableSpace variableSpace = new Variables();
  jet.copyVariablesFrom( variableSpace );

  jet.setVariable( "param6", "someDummyPreviousValue6" );
  jet.setVariable( "param7", "someDummyPreviousValue7" );

  //at this point StreamColumnNameParams are already inserted in namedParams
  NamedParams namedParam = Mockito.mock( NamedParamsDefault.class );
  Mockito.doReturn( "value1" ).when( namedParam ).getParameterValue(  "param1" );
  Mockito.doReturn( "value2" ).when( namedParam ).getParameterValue(  "param2" );
  Mockito.doReturn( "value3" ).when( namedParam ).getParameterValue(  "param3" );
  Mockito.doReturn( "value4" ).when( namedParam ).getParameterValue(  "param4" );
  Mockito.doReturn( "value5" ).when( namedParam ).getParameterValue(  "param5" );
  Mockito.doReturn( "" ).when( namedParam ).getParameterValue(  "param6" );
  Mockito.doReturn( "" ).when( namedParam ).getParameterValue(  "param7" );

  jet.prepareFieldNamesParameters( parameterNames, parameterFieldNames, parameterValues, namedParam, jet );
  // "param1" has parameterFieldName value = null and no parameterValues defined so it should be null
  Assert.assertEquals( null, jet.getVariable( "param1" ) );
  // "param2" has only parameterValues defined and no parameterFieldName value so it should be null
  Assert.assertEquals( null, jet.getVariable( "param2" ) );
  // "param3" has only the parameterFieldName defined so it should return the mocked value
  Assert.assertEquals( "value3", jet.getVariable( "param3" ) );
  // "param4" has parameterFieldName and also an empty parameterValues defined so it should return the mocked value
  Assert.assertEquals( "value4", jet.getVariable( "param4" ) );
  // "param5" has parameterFieldName and also parameterValues defined with a not empty value so it should return null
  Assert.assertEquals( null, jet.getVariable( "param5" ) );
  // "param6" only has a parameterValues defined with a not empty value and has a previous value on it ( someDummyPreviousValue6 )
  // so it should keep "someDummyPreviousValue6" since there is no parameterFieldNames definition
  Assert.assertEquals( "someDummyPreviousValue6", jet.getVariable( "param6" ) );
  // "param7" only has a parameterFieldNames defined and has a previous value on it ( someDummyPreviousValue7 )
  // so it should update to the new value mocked = "" even it is a blank value - PDI-18227
  Assert.assertEquals( "", jet.getVariable( "param7" ) );
}
 

StringEntity buildSchedulerRequestEntity( AbstractMeta meta )
        throws UnsupportedEncodingException, UnknownParamException {

  String filename = getFullPath( meta );

  JobScheduleRequest jobScheduleRequest = new JobScheduleRequest();
  jobScheduleRequest.setInputFile( filename );

  // Set the log level
  if ( meta.getLogLevel() != null ) {
    JobScheduleParam jobScheduleParam = new JobScheduleParam();
    jobScheduleParam.setName( "logLevel" );
    jobScheduleParam.setType( STRING_TYPE );
    jobScheduleParam.setStringValue( Arrays.asList( meta.getLogLevel().getCode() ) );
    jobScheduleRequest.getJobParameters().add( jobScheduleParam );
  }

  // Set the clearing log param
  JobScheduleParam jobScheduleParamClearingLog = new JobScheduleParam();
  jobScheduleParamClearingLog.setName( "clearLog" );
  jobScheduleParamClearingLog.setType( STRING_TYPE );
  jobScheduleParamClearingLog
    .setStringValue( Arrays.asList( String.valueOf( meta.isClearingLog() ) ) );
  jobScheduleRequest.getJobParameters().add( jobScheduleParamClearingLog );

  // Set the safe mode enabled param
  JobScheduleParam jobScheduleParamSafeModeEnable = new JobScheduleParam();
  jobScheduleParamSafeModeEnable.setName( "runSafeMode" );
  jobScheduleParamSafeModeEnable.setType( STRING_TYPE );
  jobScheduleParamSafeModeEnable
    .setStringValue( Arrays.asList( String.valueOf( meta.isSafeModeEnabled() ) ) );
  jobScheduleRequest.getJobParameters().add( jobScheduleParamSafeModeEnable );


  // Set the gathering metrics param
  JobScheduleParam jobScheduleParamGatheringMetricsParam = new JobScheduleParam();
  jobScheduleParamGatheringMetricsParam.setName( "gatheringMetrics" );
  jobScheduleParamGatheringMetricsParam.setType( STRING_TYPE );
  jobScheduleParamGatheringMetricsParam
    .setStringValue( Arrays.asList( String.valueOf( meta.isGatheringMetrics() ) ) );
  jobScheduleRequest.getJobParameters().add( jobScheduleParamGatheringMetricsParam );

  if ( meta instanceof JobMeta ) {
    JobMeta jobMeta = (JobMeta) meta;

    if ( jobMeta.getStartCopyName() != null ) {
      // Set the start step name
      JobScheduleParam jobScheduleParamStartStepName = new JobScheduleParam();
      jobScheduleParamStartStepName.setName( "startCopyName" );
      jobScheduleParamStartStepName.setType( STRING_TYPE );
      jobScheduleParamStartStepName.setStringValue( Arrays.asList( jobMeta.getStartCopyName() ) );
      jobScheduleRequest.getJobParameters().add( jobScheduleParamStartStepName );
    }

    // Set the expanding remote job param
    JobScheduleParam jobScheduleParamExpandingRemoteJob = new JobScheduleParam();
    jobScheduleParamExpandingRemoteJob.setName( "expandingRemoteJob" );
    jobScheduleParamExpandingRemoteJob.setType( STRING_TYPE );
    jobScheduleParamExpandingRemoteJob
      .setStringValue( Arrays.asList( String.valueOf( jobMeta.isExpandingRemoteJob() ) ) );
    jobScheduleRequest.getJobParameters().add( jobScheduleParamExpandingRemoteJob );
  }

  // Set the PDI parameters
  if ( meta.listParameters() != null ) {
    for ( String param : meta.listParameters() ) {
      jobScheduleRequest.getPdiParameters().put( param, meta.getParameterValue( param ) );
    }
  }

  // Marshal object to string
  StringWriter sw = new StringWriter();
  String jobScheduleRequestString = null;
  try {
    JAXBContext jc = JAXBContext.newInstance( JobScheduleRequest.class );
    Marshaller marshaller = jc.createMarshaller();
    marshaller.marshal( jobScheduleRequest, sw );
    jobScheduleRequestString = sw.toString();
  } catch ( JAXBException e ) {
    repository.getLog().logError( BaseMessages.getString( PKG, "SchedulerRequest.error.marshal" ), e.getMessage() );
  }

  return new StringEntity( jobScheduleRequestString );
}
 

@Override
public String getParameterDescription( String key ) throws UnknownParamException {
  return namedParams.getParameterDescription( key );
}
 

/**
 * Gets the default value of the specified parameter.
 *
 * @param key the name of the parameter
 * @return the default value of the parameter
 * @throws UnknownParamException if the parameter does not exist
 * @see org.pentaho.di.core.parameters.NamedParams#getParameterDefault(java.lang.String)
 */
@Override
public String getParameterDefault( String key ) throws UnknownParamException {
  return namedParams.getParameterDefault( key );
}
 

/**
 * Gets the description of the specified parameter.
 *
 * @param key the name of the parameter
 * @return the parameter description
 * @throws UnknownParamException if the parameter does not exist
 * @see org.pentaho.di.core.parameters.NamedParams#getParameterDescription(java.lang.String)
 */
@Override
public String getParameterDescription( String key ) throws UnknownParamException {
  return namedParams.getParameterDescription( key );
}
 

/**
 * Gets the value of the specified parameter.
 *
 * @param key the name of the parameter
 * @return the parameter value
 * @throws UnknownParamException if the parameter does not exist
 * @see org.pentaho.di.core.parameters.NamedParams#getParameterValue(java.lang.String)
 */
@Override
public String getParameterValue( String key ) throws UnknownParamException {
  return namedParams.getParameterValue( key );
}
 

/**
 * Sets the value for the specified parameter.
 *
 * @param key   the name of the parameter
 * @param value the name of the value
 * @throws UnknownParamException if the parameter does not exist
 * @see org.pentaho.di.core.parameters.NamedParams#setParameterValue(java.lang.String, java.lang.String)
 */
@Override
public void setParameterValue( String key, String value ) throws UnknownParamException {
  namedParams.setParameterValue( key, value );
}
 

/**
 * Configures the transformation with the given parameters and their values
 *
 * @param trans        the executable transformation object
 * @param optionParams the list of parameters to set for the transformation
 * @param transMeta    the transformation metadata
 * @throws UnknownParamException
 */
protected static void configureParameters( Trans trans, NamedParams optionParams,
                                           TransMeta transMeta ) throws UnknownParamException {
  PanCommandExecutor.configureParameters( trans, optionParams, transMeta );
}