private static <P extends AbstractPlugin & IGraphOutputtingFilter<?>> void connectGraphFilters(final P predecessor, final AbstractGraphFilter<?, ?, ?, ?> filter, final AnalysisController controller) throws IllegalStateException, AnalysisConfigurationException { controller.connect(predecessor, predecessor.getGraphOutputPortName(), filter, filter.getGraphInputPortName()); }
/** * * @param predecessor * @param filter * @param controller * @throws IllegalStateException * @throws AnalysisConfigurationException */ private static <P extends AbstractPlugin & IGraphOutputtingFilter<?>> void connectGraphFilters(final P predecessor, final AbstractGraphFilter<?, ?, ?, ?> filter, final AnalysisController controller) throws IllegalStateException, AnalysisConfigurationException { controller.connect(predecessor, predecessor.getGraphOutputPortName(), filter, filter.getGraphInputPortName()); }
private void printSystemEntities(final String pathPrefix, final SystemModelRepository systemEntityFactory) throws IllegalStateException, AnalysisConfigurationException { final String systemEntitiesHtmlFn = pathPrefix + "system-entities.html"; final Configuration systemModel2FileFilterConfig = new Configuration(); systemModel2FileFilterConfig.setProperty(SystemModel2FileFilter.CONFIG_PROPERTY_NAME_HTML_OUTPUT_FN, systemEntitiesHtmlFn); final SystemModel2FileFilter systemModel2FileFilter = new SystemModel2FileFilter( systemModel2FileFilterConfig, this.analysisController); // note that this plugin is (currently) not connected to any other filters this.analysisController.connect(systemModel2FileFilter, AbstractTraceAnalysisFilter.REPOSITORY_PORT_NAME_SYSTEM_MODEL, systemEntityFactory); }
private static <P extends AbstractPlugin & IGraphOutputtingFilter<?>> void attachGraphReceiver(final AnalysisController analysisController, final P deliveringPlugin, final GraphReceiverPlugin graphReceiver) throws AnalysisConfigurationException { analysisController.connect(deliveringPlugin, deliveringPlugin.getGraphOutputPortName(), graphReceiver, GraphReceiverPlugin.INPUT_PORT_NAME_GRAPHS); }
/** * * @param reader * @return * @throws IllegalStateException * @throws AnalysisConfigurationException */ private ThreadEvent2TraceEventFilter createThreadEvent2TraceEventFilter(final FSReader reader) throws IllegalStateException, AnalysisConfigurationException { // transforms thread-based events to trace-based events final ThreadEvent2TraceEventFilter threadEvent2TraceEventFilter = new ThreadEvent2TraceEventFilter(new Configuration(), this.analysisController); this.analysisController.connect(reader, FSReader.OUTPUT_PORT_NAME_RECORDS, threadEvent2TraceEventFilter, ThreadEvent2TraceEventFilter.INPUT_PORT_NAME_DEFAULT); return threadEvent2TraceEventFilter; }
private TimestampFilter createTimestampFilter(final ThreadEvent2TraceEventFilter sourceStage) throws IllegalStateException, AnalysisConfigurationException { // Create the timestamp filter and connect to the reader's output port final Configuration configTimestampFilter = new Configuration(); configTimestampFilter.setProperty(TimestampFilter.CONFIG_PROPERTY_NAME_IGNORE_BEFORE_TIMESTAMP, this.longToString(this.settings.getIgnoreExecutionsBeforeDate())); configTimestampFilter.setProperty(TimestampFilter.CONFIG_PROPERTY_NAME_IGNORE_AFTER_TIMESTAMP, this.longToString(this.settings.getIgnoreExecutionsAfterDate())); final TimestampFilter timestampFilter = new TimestampFilter(configTimestampFilter, this.analysisController); this.analysisController.connect(sourceStage, ThreadEvent2TraceEventFilter.OUTPUT_PORT_NAME_DEFAULT, timestampFilter, TimestampFilter.INPUT_PORT_NAME_EXECUTION); this.analysisController.connect(sourceStage, ThreadEvent2TraceEventFilter.OUTPUT_PORT_NAME_DEFAULT, timestampFilter, TimestampFilter.INPUT_PORT_NAME_FLOW); return timestampFilter; }
private static <P extends AbstractPlugin & IGraphOutputtingFilter<?>> TraceColoringFilter<?, ?> createTraceColoringFilter( final P predecessor, final String coloringFileName, final AnalysisController controller) throws IOException, IllegalStateException, AnalysisConfigurationException { final TraceColorRepository colorRepository = TraceColorRepository.createFromFile(coloringFileName, controller); @SuppressWarnings("rawtypes") final TraceColoringFilter<?, ?> coloringFilter = new TraceColoringFilter(new Configuration(), controller); TraceAnalysisTool.connectGraphFilters(predecessor, coloringFilter, controller); controller.connect(coloringFilter, TraceColoringFilter.COLOR_REPOSITORY_PORT_NAME, colorRepository); return coloringFilter; }
private static <P extends AbstractPlugin & IGraphOutputtingFilter<?>> TraceColoringFilter<?, ?> createTraceColoringFilter( final P predecessor, final String coloringFileName, final AnalysisController controller) throws IOException, IllegalStateException, AnalysisConfigurationException { final TraceColorRepository colorRepository = TraceColorRepository.createFromFile(coloringFileName, controller); @SuppressWarnings("rawtypes") final TraceColoringFilter<?, ?> coloringFilter = new TraceColoringFilter(new Configuration(), controller); PerformAnalysis.connectGraphFilters(predecessor, coloringFilter, controller); controller.connect(coloringFilter, TraceColoringFilter.COLOR_REPOSITORY_PORT_NAME, colorRepository); return coloringFilter; }
private static <P extends AbstractPlugin & IGraphOutputtingFilter<?>> DescriptionDecoratorFilter<?, ?, ?> createDescriptionDecoratorFilter( final P predecessor, final String descriptionsFileName, final AnalysisController controller) throws IOException, IllegalStateException, AnalysisConfigurationException { final DescriptionRepository descriptionRepository = DescriptionRepository.createFromFile(descriptionsFileName, controller); @SuppressWarnings("rawtypes") final DescriptionDecoratorFilter<?, ?, ?> descriptionFilter = new DescriptionDecoratorFilter( new Configuration(), controller); TraceAnalysisTool.connectGraphFilters(predecessor, descriptionFilter, controller); controller.connect(descriptionFilter, DescriptionDecoratorFilter.DESCRIPTION_REPOSITORY_PORT_NAME, descriptionRepository); return descriptionFilter; }
private static void connectGraphFilters(final AnalysisController analysisController, final AbstractGraphProducingFilter<?> producer, final AbstractGraphFilter<?, ?, ?, ?>[] graphFilters, final GraphReceiverPlugin graphReceiver) throws AnalysisConfigurationException { AbstractGraphFilter<?, ?, ?, ?> lastFilter = null; // Connect graph filters for (final AbstractGraphFilter<?, ?, ?, ?> filter : graphFilters) { if (lastFilter == null) { analysisController.connect(producer, producer.getGraphOutputPortName(), filter, filter.getGraphInputPortName()); } else { analysisController.connect(lastFilter, lastFilter.getGraphOutputPortName(), filter, filter.getGraphInputPortName()); } lastFilter = filter; } // Attach the graph receiver at the appropriate position if (lastFilter == null) { DependencyGraphTestUtil.attachGraphReceiver(analysisController, producer, graphReceiver); } else { DependencyGraphTestUtil.attachGraphReceiver(analysisController, lastFilter, graphReceiver); } }
@Test public void testIt() throws Exception { final AbstractTraceProcessingFilter filter = this.provideWriterFilter(this.outputFile.getAbsolutePath(), this.analysisController); final ListReader<Object> reader = new ListReader<Object>(new Configuration(), this.analysisController); final List<Object> eventList = this.createTraces(); reader.addAllObjects(eventList); this.analysisController.connect(reader, ListReader.OUTPUT_PORT_NAME, filter, this.provideFilterInputName()); this.analysisController.connect(filter, AbstractTraceAnalysisFilter.REPOSITORY_PORT_NAME_SYSTEM_MODEL, this.modelRepo); this.analysisController.run(); final String actualFileContent = StringUtils.readOutputFileAsString(this.outputFile); final String expectedFileContent = this.provideExpectedFileContent(eventList); Assert.assertEquals("Unexpected file content", expectedFileContent, actualFileContent); }
@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; }
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); } } }; }
@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" }
@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(); }
/** * Initializes the test setup. * * @throws AnalysisConfigurationException * If the preparation of the analysis failed. */ @BeforeClass public static void prepareSetup() throws AnalysisConfigurationException { final AnalysisController analysisController = new AnalysisController(); final ComponentDependencyGraphAllocationFilter filter = new ComponentDependencyGraphAllocationFilter(new Configuration(), analysisController); final String inputPortName = AbstractMessageTraceProcessingFilter.INPUT_PORT_NAME_MESSAGE_TRACES; final String repositoryPortName = AbstractTraceAnalysisFilter.REPOSITORY_PORT_NAME_SYSTEM_MODEL; @SuppressWarnings("rawtypes") final DescriptionDecoratorFilter<?, ?, ?> descriptionDecoratorFilter = new DescriptionDecoratorFilter(new Configuration(), analysisController); final DescriptionRepository descriptionRepository = DescriptionDecoratorFilterTest.prepareDescriptionRepository(analysisController); testSetup = DependencyGraphTestUtil.prepareEnvironmentForGraphFilterTest(analysisController, filter, inputPortName, repositoryPortName, DescriptionDecoratorFilterTest.createExecutionRecords(), descriptionDecoratorFilter); analysisController.connect(descriptionDecoratorFilter, DescriptionDecoratorFilter.DESCRIPTION_REPOSITORY_PORT_NAME, descriptionRepository); }
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(); } }
/** * Prepares the setup for the test. * * @throws AnalysisConfigurationException * If the setup of the filters failed. */ @BeforeClass public static void prepareSetup() throws AnalysisConfigurationException { final AnalysisController analysisController = new AnalysisController(); final ComponentDependencyGraphAllocationFilter filter = new ComponentDependencyGraphAllocationFilter(new Configuration(), analysisController); final String inputPortName = AbstractMessageTraceProcessingFilter.INPUT_PORT_NAME_MESSAGE_TRACES; final String repositoryPortName = AbstractTraceAnalysisFilter.REPOSITORY_PORT_NAME_SYSTEM_MODEL; @SuppressWarnings("rawtypes") final TraceColoringFilter<?, ?> traceColoringFilter = new TraceColoringFilter(new Configuration(), analysisController); final TraceColorRepository traceColorRepository = TraceColoringFilterTest.prepareTraceColorRepository(analysisController); testSetup = DependencyGraphTestUtil.prepareEnvironmentForGraphFilterTest(analysisController, filter, inputPortName, repositoryPortName, TraceColoringFilterTest.createExecutionRecords(), traceColoringFilter); analysisController.connect(traceColoringFilter, TraceColoringFilter.COLOR_REPOSITORY_PORT_NAME, traceColorRepository); }