@Override protected MonitoringController createController(final int numRecordsWritten) throws IllegalStateException, AnalysisConfigurationException, InterruptedException { final AnalysisController analysisController = new AnalysisController(); final Configuration config = ConfigurationFactory.createDefaultConfiguration(); config.setProperty(ConfigurationKeys.WRITER_CLASSNAME, JmsWriter.class.getName()); config.setProperty(JmsWriter.CONFIG_CONTEXTFACTORYTYPE, FakeInitialContextFactory.class.getName()); config.setProperty(JmsWriter.CONFIG_FACTORYLOOKUPNAME, "ConnectionFactory"); final MonitoringController ctrl = MonitoringController.createInstance(config); Thread.sleep(1000); final Configuration jmsReaderConfig = new Configuration(); jmsReaderConfig.setProperty(JmsReader.CONFIG_PROPERTY_NAME_FACTORYLOOKUP, FakeInitialContextFactory.class.getName()); final JmsReader jmsReader = new JmsReader(jmsReaderConfig, analysisController); this.sinkFilter = new ListCollectionFilter<IMonitoringRecord>(new Configuration(), analysisController); analysisController.connect(jmsReader, JmsReader.OUTPUT_PORT_NAME_RECORDS, this.sinkFilter, ListCollectionFilter.INPUT_PORT_NAME); final AnalysisControllerThread analysisThread = new AnalysisControllerThread(analysisController); analysisThread.start(); Thread.sleep(1000); return ctrl; }
/** * This method initializes the setup. */ @Before public void before() { this.controller = new AnalysisController(); this.reader = new ListReader<>(new Configuration(), this.controller); this.sinkPlugin = new ListCollectionFilter<>(new Configuration(), this.controller); }
public TestAnalysis(final Configuration configuration, final Class<? extends AbstractReaderPlugin> readerClass) throws Exception { this.analysisController = new AnalysisController(); final AbstractReaderPlugin reader = this.newReader(readerClass, configuration, this.analysisController); final String outputPortName = reader.getAllOutputPortNames()[0]; this.sinkPlugin = new ListCollectionFilter<IMonitoringRecord>(new Configuration(), this.analysisController); this.analysisController.connect(reader, outputPortName, this.sinkPlugin, ListCollectionFilter.INPUT_PORT_NAME); this.thread = new Thread("TestAnalysis thread") { @Override public void run() { try { TestAnalysis.this.getAnalysisController().run(); } catch (IllegalStateException | AnalysisConfigurationException e) { throw new IllegalStateException("Should never happen", e); } } }; }
final ListReader<Object> reader = new ListReader<Object>(new Configuration(), controller); final TypeFilter typeFilter = new TypeFilter(typeFilterConfiguration, controller); final ListCollectionFilter<Object> sinkPluginValidElements = new ListCollectionFilter<Object>(new Configuration(), controller); final ListCollectionFilter<Object> sinkPluginInvalidElements = new ListCollectionFilter<Object>(new Configuration(), controller);
public List<IMonitoringRecord> runAnalysis(final File workingDirectory) throws IllegalStateException, AnalysisConfigurationException { final File[] directories = workingDirectory.listFiles(FILE_FILTER); if (null == directories) { return Collections.emptyList(); } final Configuration conf = new Configuration(); final AnalysisController analysisController = new AnalysisController(); try { conf.setProperty(AsciiLogReader.CONFIG_PROPERTY_NAME_INPUTDIRS, Configuration.toProperty(directories)); final AsciiLogReader reader = new AsciiLogReader(conf, analysisController); final ListCollectionFilter<IMonitoringRecord> collectionSink = new ListCollectionFilter<>( new Configuration(), analysisController); analysisController.connect(reader, AsciiLogReader.OUTPUT_PORT_NAME_RECORDS, collectionSink, ListCollectionFilter.INPUT_PORT_NAME); analysisController.run(); return collectionSink.getList(); } finally { this.deleteTempoararyFiles(directories); } }
@Override protected MonitoringController createController(final int numRecordsWritten) throws IllegalStateException, AnalysisConfigurationException, InterruptedException { this.analysisController = new AnalysisController(); final Configuration readerConfig = new Configuration(); readerConfig.setProperty(SingleSocketTcpReader.CONFIG_PROPERTY_NAME_PORT, SingleSocketTcpWriterReaderTest.PORT1); // readerConfig.setProperty(SingleSocketTcpReader.CONFIG_PROPERTY_NAME_PORT1, SingleSocketTcpWriterReaderTest.PORT1); // readerConfig.setProperty(SingleSocketTcpReader.CONFIG_PROPERTY_NAME_PORT2, SingleSocketTcpWriterReaderTest.PORT2); final SingleSocketTcpReader tcpReader = new SingleSocketTcpReader(readerConfig, this.analysisController); this.sinkFilter = new ListCollectionFilter<IMonitoringRecord>(new Configuration(), this.analysisController); this.analysisController.connect(tcpReader, SingleSocketTcpReader.OUTPUT_PORT_NAME_RECORDS, this.sinkFilter, ListCollectionFilter.INPUT_PORT_NAME); this.analysisThread = new AnalysisControllerThread(this.analysisController); this.analysisThread.start(); Thread.sleep(1000); final Configuration monitoringConfig = ConfigurationFactory.createDefaultConfiguration(); monitoringConfig.setProperty(ConfigurationKeys.WRITER_CLASSNAME, SingleSocketTcpWriter.class.getName()); monitoringConfig.setProperty(SingleSocketTcpWriter.CONFIG_PORT, SingleSocketTcpWriterReaderTest.PORT1); return MonitoringController.createInstance(monitoringConfig); }
@Override protected MonitoringController createController(final int numRecordsWritten) throws IllegalStateException, AnalysisConfigurationException, InterruptedException { this.analysisController = new AnalysisController(); final Configuration readerConfig = new Configuration(); readerConfig.setProperty(SingleSocketTcpReader.CONFIG_PROPERTY_NAME_PORT, NewSingleSocketTcpWriterReaderTest.PORT1); // readerConfig.setProperty(SingleSocketTcpReader.CONFIG_PROPERTY_NAME_PORT1, SingleSocketTcpWriterReaderTest.PORT1); // readerConfig.setProperty(SingleSocketTcpReader.CONFIG_PROPERTY_NAME_PORT2, SingleSocketTcpWriterReaderTest.PORT2); final SingleSocketTcpReader tcpReader = new SingleSocketTcpReader(readerConfig, this.analysisController); this.sinkFilter = new ListCollectionFilter<IMonitoringRecord>(new Configuration(), this.analysisController); this.analysisController.connect(tcpReader, SingleSocketTcpReader.OUTPUT_PORT_NAME_RECORDS, this.sinkFilter, ListCollectionFilter.INPUT_PORT_NAME); this.analysisThread = new AnalysisControllerThread(this.analysisController); this.analysisThread.start(); Thread.sleep(1000); final Configuration monitoringConfig = ConfigurationFactory.createDefaultConfiguration(); monitoringConfig.setProperty(ConfigurationKeys.WRITER_CLASSNAME, SingleSocketTcpWriter.class.getName()); monitoringConfig.setProperty(SingleSocketTcpWriter.CONFIG_PORT, NewSingleSocketTcpWriterReaderTest.PORT1); return MonitoringController.createInstance(monitoringConfig); }
@Before public void setUp() throws Exception { final AnalysisController analysisController = new AnalysisController(); final Configuration pipeReaderConfig = new Configuration(); pipeReaderConfig.setProperty(PipeReader.CONFIG_PROPERTY_NAME_PIPENAME, BasicNamedRecordPipeWriterReaderTest.PIPE_NAME); final PipeReader pipeReader = new PipeReader(pipeReaderConfig, analysisController); this.sinkFilter = new ListCollectionFilter<IMonitoringRecord>(new Configuration(), analysisController); analysisController.connect(pipeReader, PipeReader.OUTPUT_PORT_NAME_RECORDS, this.sinkFilter, ListCollectionFilter.INPUT_PORT_NAME); final AnalysisControllerThread analysisThread = new AnalysisControllerThread(analysisController); analysisThread.start(); }
@Override protected MonitoringController createController(final int numRecordsWritten) throws IllegalStateException, AnalysisConfigurationException, InterruptedException { this.analysisController = new AnalysisController(); final Configuration readerConfig = new Configuration(); readerConfig.setProperty(DualSocketTcpReader.CONFIG_PROPERTY_NAME_PORT1, DualSocketTcpWriterReaderTest.PORT1); readerConfig.setProperty(DualSocketTcpReader.CONFIG_PROPERTY_NAME_PORT2, DualSocketTcpWriterReaderTest.PORT2); final DualSocketTcpReader tcpReader = new DualSocketTcpReader(readerConfig, this.analysisController); this.sinkFilter = new ListCollectionFilter<IMonitoringRecord>(new Configuration(), this.analysisController); this.analysisController.connect(tcpReader, DualSocketTcpReader.OUTPUT_PORT_NAME_RECORDS, this.sinkFilter, ListCollectionFilter.INPUT_PORT_NAME); this.analysisThread = new AnalysisControllerThread(this.analysisController); this.analysisThread.start(); Thread.sleep(1000); final Configuration monitoringConfig = ConfigurationFactory.createDefaultConfiguration(); monitoringConfig.setProperty(ConfigurationKeys.WRITER_CLASSNAME, DualSocketTcpWriter.class.getName()); monitoringConfig.setProperty(DualSocketTcpWriter.CONFIG_PORT1, DualSocketTcpWriterReaderTest.PORT1); monitoringConfig.setProperty(DualSocketTcpWriter.CONFIG_PORT2, DualSocketTcpWriterReaderTest.PORT2); return MonitoringController.createInstance(monitoringConfig); }
private void runTestFailed(final TraceEventRecords records, final long maxTraceDuration, final long maxTraceTimeout) throws IllegalStateException, AnalysisConfigurationException { final IAnalysisController controller = new AnalysisController(); final ListReader<Object> reader = new ListReader<>(new Configuration(), controller); final Configuration configuration = new Configuration(); configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_DURATION, Long.toString(maxTraceDuration)); configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_TIMEOUT, Long.toString(maxTraceTimeout)); final EventRecordTraceReconstructionFilter traceFilter = new EventRecordTraceReconstructionFilter(configuration, controller); final ListCollectionFilter<TraceEventRecords> sinkPlugin = new ListCollectionFilter<>(new Configuration(), controller); Assert.assertTrue(sinkPlugin.getList().isEmpty()); controller.connect(reader, ListReader.OUTPUT_PORT_NAME, traceFilter, EventRecordTraceReconstructionFilter.INPUT_PORT_NAME_TRACE_RECORDS); controller.connect(traceFilter, EventRecordTraceReconstructionFilter.OUTPUT_PORT_NAME_TRACE_VALID, sinkPlugin, ListCollectionFilter.INPUT_PORT_NAME); reader.addObject(records.getTraceMetadata()); for (final AbstractTraceEvent e : records.getTraceEvents()) { reader.addObject(e); } controller.run(); Assert.assertEquals(AnalysisController.STATE.TERMINATED, controller.getState()); // Make sure that no trace is generated Assert.assertEquals("There should be no trace", 0, sinkPlugin.getList().size()); }
private void runTestFailedInterleaved(final TraceEventRecords trace1, final TraceEventRecords trace2, final long maxTraceDuration, final long maxTraceTimeout) throws IllegalStateException, AnalysisConfigurationException { final IAnalysisController controller = new AnalysisController(); final ListReader<Object> reader = new ListReader<>(new Configuration(), controller); final Configuration configuration = new Configuration(); configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_DURATION, Long.toString(maxTraceDuration)); configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_TIMEOUT, Long.toString(maxTraceTimeout)); final EventRecordTraceReconstructionFilter traceFilter = new EventRecordTraceReconstructionFilter(configuration, controller); final ListCollectionFilter<TraceEventRecords> sinkPlugin = new ListCollectionFilter<>(new Configuration(), controller); Assert.assertTrue(sinkPlugin.getList().isEmpty()); final ListCollectionFilter<TraceEventRecords> sinkPluginFailed = new ListCollectionFilter<>(new Configuration(), controller); Assert.assertTrue(sinkPluginFailed.getList().isEmpty()); controller.connect(reader, ListReader.OUTPUT_PORT_NAME, traceFilter, EventRecordTraceReconstructionFilter.INPUT_PORT_NAME_TRACE_RECORDS); controller.connect(traceFilter, EventRecordTraceReconstructionFilter.OUTPUT_PORT_NAME_TRACE_VALID, sinkPlugin, ListCollectionFilter.INPUT_PORT_NAME); controller.connect(traceFilter, EventRecordTraceReconstructionFilter.OUTPUT_PORT_NAME_TRACE_INVALID, sinkPluginFailed, ListCollectionFilter.INPUT_PORT_NAME); reader.addObject(trace1.getTraceMetadata()); reader.addObject(trace2.getTraceMetadata()); final AbstractTraceEvent[] events1 = trace1.getTraceEvents(); final AbstractTraceEvent[] events2 = trace2.getTraceEvents(); for (int i = 0; i < events1.length; i++) { reader.addObject(events1[i]); reader.addObject(events2[i]); } controller.run(); Assert.assertEquals(AnalysisController.STATE.TERMINATED, controller.getState()); // Make sure that only one of the two traces is generated Assert.assertEquals("There should be no trace", 1, sinkPlugin.getList().size()); }
final EventRecordTraceReconstructionFilter traceFilter = new EventRecordTraceReconstructionFilter(configuration, controller); final ListCollectionFilter<TraceEventRecords> sinkPlugin = new ListCollectionFilter<>(new Configuration(), controller); Assert.assertTrue(sinkPlugin.getList().isEmpty());
this.analysisController); final ListCollectionFilter<ExecutionTrace> executionTraceSinkPlugin = new ListCollectionFilter<ExecutionTrace>(new Configuration(), this.analysisController);
private void runTestEventBasedTraceRepair(final TraceEventRecords records, final long maxTraceDuration, final long maxTraceTimeout) throws IllegalStateException, AnalysisConfigurationException { final IAnalysisController controller = new AnalysisController(); final ListReader<Object> reader = new ListReader<>(new Configuration(), controller); final Configuration configuration = new Configuration(); configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_DURATION, Long.toString(maxTraceDuration)); configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_TIMEOUT, Long.toString(maxTraceTimeout)); configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_REPAIR_EVENT_BASED_TRACES, "true"); final EventRecordTraceReconstructionFilter traceFilter = new EventRecordTraceReconstructionFilter(configuration, controller); final ListCollectionFilter<TraceEventRecords> sinkPlugin = new ListCollectionFilter<>(new Configuration(), controller); Assert.assertTrue(sinkPlugin.getList().isEmpty()); controller.connect(reader, ListReader.OUTPUT_PORT_NAME, traceFilter, EventRecordTraceReconstructionFilter.INPUT_PORT_NAME_TRACE_RECORDS); controller.connect(traceFilter, EventRecordTraceReconstructionFilter.OUTPUT_PORT_NAME_TRACE_VALID, sinkPlugin, ListCollectionFilter.INPUT_PORT_NAME); reader.addObject(records.getTraceMetadata()); for (final AbstractTraceEvent e : records.getTraceEvents()) { reader.addObject(e); } controller.run(); Assert.assertEquals(AnalysisController.STATE.TERMINATED, controller.getState()); Assert.assertEquals("No trace passed filter", 1, sinkPlugin.getList().size()); Assert.assertTrue("Repair failed", records.getTraceEvents().length < sinkPlugin.getList().get(0).getTraceEvents().length); Assert.assertEquals("Did not repair all BeforeEvents", sinkPlugin.getList().get(0).getTraceEvents().length, 10); }
/** * Set up for the AnomalyScoreCalculationFilterTest. * * @throws IllegalStateException * If illegal state * @throws AnalysisConfigurationException * If wrong configuration */ @Before public void setUp() throws IllegalStateException, AnalysisConfigurationException { this.controller = new AnalysisController(); // READER final Configuration readerScoreCalcConfiguration = new Configuration(); readerScoreCalcConfiguration.setProperty(ListReader.CONFIG_PROPERTY_NAME_AWAIT_TERMINATION, Boolean.TRUE.toString()); final ListReader<ForecastMeasurementPair> theReaderScoreCalc = new ListReader<>(readerScoreCalcConfiguration, this.controller); theReaderScoreCalc.addAllObjects(this.createInputEventSetScoreCalc()); final Configuration scoreConfiguration = new Configuration(); final AnomalyScoreCalculationFilter scoreCalc = new AnomalyScoreCalculationFilter(scoreConfiguration, this.controller); // SINK 1 this.sinkAnomalyScore = new ListCollectionFilter<>(new Configuration(), this.controller); // CONNECTION this.controller .connect(theReaderScoreCalc, ListReader.OUTPUT_PORT_NAME, scoreCalc, AnomalyScoreCalculationFilter.INPUT_PORT_CURRENT_FORECAST_PAIR); this.controller .connect(scoreCalc, AnomalyScoreCalculationFilter.OUTPUT_PORT_ANOMALY_SCORE, this.sinkAnomalyScore, ListCollectionFilter.INPUT_PORT_NAME); }
this.sinkPlugin = new ListCollectionFilter<>(new Configuration(), this.controller); Assert.assertTrue(this.sinkPlugin.getList().isEmpty());
@Ignore // NOCS @Test public void testRecordsWithoutStringSame() throws IllegalStateException, AnalysisConfigurationException { final AnalysisController analysisController = new AnalysisController(); final ListReader<IMonitoringRecord> reader = new ListReader<>(new Configuration(), analysisController); final StringBufferFilter stringBufferFilter = new StringBufferFilter(new Configuration(), analysisController); final ListCollectionFilter<IMonitoringRecord> collectionFilter = new ListCollectionFilter<>(new Configuration(), analysisController); analysisController.connect(reader, ListReader.OUTPUT_PORT_NAME, stringBufferFilter, StringBufferFilter.INPUT_PORT_NAME_EVENTS); analysisController.connect(stringBufferFilter, StringBufferFilter.OUTPUT_PORT_NAME_RELAYED_EVENTS, collectionFilter, ListCollectionFilter.INPUT_PORT_NAME); final IMonitoringRecord recordIn1 = new EmptyRecord(); reader.addObject(recordIn1); analysisController.run(); Assert.assertEquals(AnalysisController.STATE.TERMINATED, analysisController.getState()); final List<IMonitoringRecord> records = collectionFilter.getList(); Assert.assertEquals("Unexpected number of records", 1, records.size()); final IMonitoringRecord recordOut1 = records.get(0); Assert.assertSame("First output record not same as first input record", recordIn1, recordOut1); // includes no String, hence "as-is" }
private List<IMonitoringRecord> readLog(final String[] monitoringLogDirs) throws AnalysisConfigurationException { final AnalysisController analysisController = new AnalysisController(); final Configuration readerConfiguration = new Configuration(); readerConfiguration.setProperty(AsciiLogReader.CONFIG_PROPERTY_NAME_INPUTDIRS, Configuration.toProperty(monitoringLogDirs)); readerConfiguration.setProperty(AsciiLogReader.CONFIG_PROPERTY_NAME_IGNORE_UNKNOWN_RECORD_TYPES, "false"); final AbstractReaderPlugin reader = new AsciiLogReader(readerConfiguration, analysisController); final ListCollectionFilter<IMonitoringRecord> sinkPlugin = new ListCollectionFilter<>(new Configuration(), analysisController); analysisController.connect(reader, AsciiLogReader.OUTPUT_PORT_NAME_RECORDS, sinkPlugin, ListCollectionFilter.INPUT_PORT_NAME); analysisController.run(); Assert.assertEquals(AnalysisController.STATE.TERMINATED, analysisController.getState()); return sinkPlugin.getList(); } }
@Ignore // NOCS @Test public void testRecordsWithStringEqualButNeverSame() throws IllegalStateException, AnalysisConfigurationException { final IAnalysisController analysisController = new AnalysisController(); final ListReader<IMonitoringRecord> reader = new ListReader<>(new Configuration(), analysisController); final StringBufferFilter stringBufferFilter = new StringBufferFilter(new Configuration(), analysisController); final ListCollectionFilter<IMonitoringRecord> collectionFilter = new ListCollectionFilter<>(new Configuration(), analysisController); analysisController.connect(reader, ListReader.OUTPUT_PORT_NAME, stringBufferFilter, StringBufferFilter.INPUT_PORT_NAME_EVENTS); analysisController.connect(stringBufferFilter, StringBufferFilter.OUTPUT_PORT_NAME_RELAYED_EVENTS, collectionFilter, ListCollectionFilter.INPUT_PORT_NAME); long timestamp = 3268936L; final IMonitoringRecord recordIn1 = TestStringBufferFilter.createOperationExecutionRecord(timestamp); timestamp++; final IMonitoringRecord recordIn2 = TestStringBufferFilter.createOperationExecutionRecord(timestamp); reader.addObject(recordIn1); reader.addObject(recordIn2); analysisController.run(); Assert.assertEquals(AnalysisController.STATE.TERMINATED, analysisController.getState()); final List<IMonitoringRecord> records = collectionFilter.getList(); Assert.assertEquals("Unexpected number of records", 2, records.size()); final IMonitoringRecord recordOut1 = records.get(0); final IMonitoringRecord recordOut2 = records.get(1); Assert.assertNotSame("First output record same as first input record", recordIn1, recordOut1); // includes String, hence NOT "as-is" Assert.assertEquals("First output record doesn't equal first input record", recordIn1, recordOut1); // ... but must be equal Assert.assertNotSame("Second output record same as second input record", recordIn2, recordOut2); // includes String, hence NOT "as-is" Assert.assertEquals("Second output record doesn't equal second input record", recordIn2, recordOut2); // ... but must be equal }
/** * Sets up a simple test filter structure (SimpleListReader -> RecordConverter -> ListCollectionFilter) * and creates an OperationExecutionRecord that will be converterd for testing reasons. * * @throws Exception * throws exceptions that are thrown while setting up the filter structure */ @Before public void setUp() throws Exception { final OperationExecutionRecord oer; final RecordConverter recordConverter; this.analysisController = new AnalysisController(); recordConverter = new RecordConverter(new Configuration(), this.analysisController); this.simpleListReader = new ListReader<OperationExecutionRecord>(new Configuration(), this.analysisController); this.listCollectionfilter = new ListCollectionFilter<NamedDoubleRecord>(new Configuration(), this.analysisController); this.analysisController.connect(this.simpleListReader, ListReader.OUTPUT_PORT_NAME, recordConverter, RecordConverter.INPUT_PORT_NAME_OER); this.analysisController.connect(recordConverter, RecordConverter.OUTPUT_PORT_NAME_NDR, this.listCollectionfilter, ListCollectionFilter.INPUT_PORT_NAME); oer = new OperationExecutionRecord(RecordConverterTest.operationSignature, OperationExecutionRecord.NO_SESSION_ID, OperationExecutionRecord.NO_TRACE_ID, RecordConverterTest.timeIn, RecordConverterTest.timeOut, RecordConverterTest.hostAppInput, OperationExecutionRecord.NO_EOI_ESS, OperationExecutionRecord.NO_EOI_ESS); oer.setLoggingTimestamp(RecordConverterTest.loggingTimestamp); this.convertRecord(oer); }