How to use

updateSensorParserConfig

method

in

org.apache.metron.common.configuration.ParserConfigurations

public void updateSensorParserConfig(String sensorType, byte[] data) throws IOException {
 updateSensorParserConfig(sensorType, new ByteArrayInputStream(data));
}

public StellarParserRunner withParserConfiguration(String sensorType, SensorParserConfig config) {
  parserConfigurations = new ParserConfigurations();
  parserConfigurations.updateSensorParserConfig(sensorType, config);
  return this;
}

@Override
public void update(String name, byte[] data) throws IOException {
 getConfigurations().updateSensorParserConfig(name, data);
}

public void updateSensorParserConfig(String sensorType, InputStream io) throws IOException {
 SensorParserConfig sensorParserConfig = JSONUtils.INSTANCE.load(io, SensorParserConfig.class);
 updateSensorParserConfig(sensorType, sensorParserConfig);
}

private ParserConfigurations create(byte[] sensorConfig) {
  try {
    ParserConfigurations result = new ParserConfigurations();
    result.updateSensorParserConfig(sensorType, SensorParserConfig.fromBytes(sensorConfig));
    return result;
  } catch(IOException e) {
    throw new IllegalArgumentException(e);
  }
}

public static void updateParserConfigsFromZookeeper(ParserConfigurations configurations, CuratorFramework client) throws Exception {
 updateConfigsFromZookeeper( configurations
              , PARSER
              , sensorType -> configurations.updateSensorParserConfig(sensorType, readSensorParserConfigBytesFromZookeeper(sensorType, client))
              , client
              );
}

public static ParserConfigurations getSampleParserConfigs() throws IOException {
 ParserConfigurations configurations = new ParserConfigurations();
 configurations.updateGlobalConfig(ConfigurationsUtils.readGlobalConfigFromFile(TestConstants.SAMPLE_CONFIG_PATH));
 Map<String, byte[]> sensorParserConfigs = ConfigurationsUtils.readSensorParserConfigsFromFile(TestConstants.PARSER_CONFIGS_PATH);
 for(String sensorType: sensorParserConfigs.keySet()) {
  configurations.updateSensorParserConfig(sensorType, sensorParserConfigs.get(sensorType));
 }
 return configurations;
}

 @Override
 public ParserConfigurations getConfigurations() {
  ParserConfigurations configurations = new ParserConfigurations();
  SensorParserConfig sensorParserConfig = new SensorParserConfig();
  sensorParserConfig.setParserConfig(new HashMap<String, Object>() {{
    put(IndexingConfigurations.BATCH_SIZE_CONF, 10);
  }});
  configurations.updateSensorParserConfig("yaf", sensorParserConfig);
  return configurations;
 }
};

@Before
public void setup() throws IOException {
 parserConfigurations = new ParserConfigurations();
 SensorParserConfig broConfig = SensorParserConfig.fromBytes(broConfigString.getBytes());
 SensorParserConfig snortConfig = SensorParserConfig.fromBytes(snortConfigString.getBytes());
 parserConfigurations.updateSensorParserConfig("bro", broConfig);
 parserConfigurations.updateSensorParserConfig("snort", snortConfig);
 parserConfigurations.updateGlobalConfig(JSONUtils.INSTANCE.load(globalConfigString, JSONUtils.MAP_SUPPLIER));
 parserRunner = new ParserRunnerImpl(new HashSet<>(Arrays.asList("bro", "snort")));
 broParser = mock(MessageParser.class);
 snortParser = mock(MessageParser.class);
 stellarFilter = mock(StellarFilter.class);
 mockStatic(ReflectionUtils.class);
 mockStatic(Filters.class);
 when(ReflectionUtils.createInstance("org.apache.metron.parsers.bro.BasicBroParser")).thenReturn(broParser);
 when(ReflectionUtils.createInstance("org.apache.metron.parsers.snort.BasicSnortParser")).thenReturn(snortParser);
 when(Filters.get("org.apache.metron.parsers.filters.StellarFilter", broConfig.getParserConfig()))
     .thenReturn(stellarFilter);
}

@Test
public void pulls_writer_configuration_from_parserConfig() throws IOException {
 ParserConfigurations parserConfigurations = new ParserConfigurations();
 final String sensorName = "some-sensor";
 parserConfigurations.updateSensorParserConfig("some-sensor", configJson.getBytes());
 ParserWriterConfiguration writerConfiguration = new ParserWriterConfiguration(
   parserConfigurations);
 assertThat("batch size should match", writerConfiguration.getBatchSize(sensorName), equalTo(5));
 assertThat("batch timeout should match", writerConfiguration.getBatchTimeout(sensorName), equalTo(10000));
 assertThat("index should match", writerConfiguration.getIndex(sensorName), equalTo("modified-index"));
 assertThat("enabled should match", writerConfiguration.isEnabled(sensorName), equalTo(false));
}

public ParserDriver(String sensorType, String parserConfig, String globalConfig)
  throws IOException {
 SensorParserConfig sensorParserConfig = SensorParserConfig.fromBytes(parserConfig.getBytes());
 this.sensorType = sensorType == null ? sensorParserConfig.getSensorTopic() : sensorType;
 config = new ParserConfigurations();
 config.updateSensorParserConfig(this.sensorType,
   SensorParserConfig.fromBytes(parserConfig.getBytes()));
 config.updateGlobalConfig(JSONUtils.INSTANCE.load(globalConfig, JSONUtils.MAP_SUPPLIER));
 parserRunner = new ParserRunnerImpl(new HashSet<String>() {{
  add(sensorType);
 }});
}

parserConfigurations.updateSensorParserConfig("yaf", new SensorParserConfig());
doThrow(new IllegalStateException("parserRunner.execute failed")).when(parserRunner).execute(eq("yaf"), any(), eq(parserConfigurations));

MockParserRunner mockParserRunner = new MockParserRunner(new HashSet<String>() {{ add("yaf"); }});
ParserConfigurations parserConfigurations = new ParserConfigurations();
parserConfigurations.updateSensorParserConfig("yaf", new SensorParserConfig());
doThrow(new IllegalStateException("write failed")).when(writerHandler).write(any(), any(), any(), any(), any());

MockParserRunner mockParserRunner = new MockParserRunner(new HashSet<String>() {{ add("yaf"); }});
ParserConfigurations parserConfigurations = new ParserConfigurations();
parserConfigurations.updateSensorParserConfig("yaf", new SensorParserConfig());

@Test
public void sensorParserConfig_properties_populated_by_JSON_configuration() throws IOException {
 ParserConfigurations parserConfigs = new ParserConfigurations();
 parserConfigs.updateSensorParserConfig("test-sensor", parserConfig.getBytes());
 SensorParserConfig actualSensorConfig = parserConfigs.getSensorParserConfig("test-sensor");
 assertThat(actualSensorConfig.getParserClassName(), equalTo("parser-class"));

mockParserRunner.setInvalid(true);
ParserConfigurations parserConfigurations = new ParserConfigurations();
parserConfigurations.updateSensorParserConfig("yaf", new SensorParserConfig());

Map<String, byte[]> sensorParserConfigs = ConfigurationsUtils.readSensorParserConfigsFromFile(TestConstants.PARSER_CONFIGS_PATH);
for (String sensorType : sensorParserConfigs.keySet()) {
 sampleConfigurations.updateSensorParserConfig(sensorType, sensorParserConfigs.get(sensorType));
 put("configName", "configObject");
}});
sampleConfigurations.updateSensorParserConfig(sensorType, testSensorConfig);
ConfigurationsUtils.writeSensorParserConfigToZookeeper(sensorType, testSensorConfig, zookeeperUrl);
waitForConfigUpdate(sensorType);