/** * getServiceTypeNames * * @return a {@link java.util.Collection} object. */ @Override public Collection<String> getServiceTypeNames(String groupName) { final SortedSet<String> serviceNames = new TreeSet<String>(); m_readLock.lock(); try { m_pendingForeignSourceRepository.flush(); final ForeignSource pendingForeignSource = m_pendingForeignSourceRepository.getForeignSource(groupName); serviceNames.addAll(pendingForeignSource.getDetectorNames()); m_deployedForeignSourceRepository.flush(); final ForeignSource deployedForeignSource = m_deployedForeignSourceRepository.getForeignSource(groupName); serviceNames.addAll(deployedForeignSource.getDetectorNames()); for (final OnmsServiceType type : m_serviceTypeDao.findAll()) { serviceNames.add(type.getName()); } serviceNames.addAll(m_capsdConfig.getConfiguredProtocols()); return serviceNames; } finally { m_readLock.unlock(); } }
/** {@inheritDoc} */ public List<ServiceDetector> getDetectorsForForeignSource(final String foreignSourceName) { final ForeignSource foreignSource = m_foreignSourceRepository.getForeignSource(foreignSourceName); assertNotNull(foreignSource, "Expected a foreignSource with name %s", foreignSourceName); final List<PluginConfig> detectorConfigs = foreignSource.getDetectors(); if (detectorConfigs == null) { return new ArrayList<ServiceDetector>(m_pluginRegistry.getAllPlugins(ServiceDetector.class)); } final List<ServiceDetector> detectors = new ArrayList<ServiceDetector>(detectorConfigs.size()); for (final PluginConfig detectorConfig : detectorConfigs) { final ServiceDetector detector = m_pluginRegistry.getPluginInstance(ServiceDetector.class, detectorConfig); if (detector == null) { errorf(this, "Configured plugin does not exist: %s", detectorConfig); } else { detector.setServiceName(detectorConfig.getName()); detector.init(); detectors.add(detector); } } return detectors; }
private NodeScanSchedule createScheduleForNode(final OnmsNode node, final boolean force) { Assert.notNull(node, "Node may not be null"); final String actualForeignSource = node.getForeignSource(); if (actualForeignSource == null && !isDiscoveryEnabled()) { infof( this, "Not scheduling node %s to be scanned since it has a null foreignSource and handling of discovered nodes is disabled in provisiond", node); return null; } final String effectiveForeignSource = actualForeignSource == null ? "default" : actualForeignSource; try { final ForeignSource fs = m_foreignSourceRepository.getForeignSource(effectiveForeignSource); final Duration scanInterval = fs.getScanInterval(); Duration initialDelay = Duration.ZERO; if (node.getLastCapsdPoll() != null && !force) { final DateTime nextPoll = new DateTime(node.getLastCapsdPoll().getTime()).plus(scanInterval); final DateTime now = new DateTime(); if (nextPoll.isAfter(now)) { initialDelay = new Duration(now, nextPoll); } } return new NodeScanSchedule( node.getId(), actualForeignSource, node.getForeignId(), initialDelay, scanInterval); } catch (final ForeignSourceRepositoryException e) { warnf(this, e, "unable to get foreign source '%s' from repository", effectiveForeignSource); return null; } }
/** * getPluginsForForeignSource * * @param pluginClass a {@link java.lang.Class} object. * @param foreignSourceName a {@link java.lang.String} object. * @param <T> a T object. * @return a {@link java.util.List} object. */ public <T> List<T> getPluginsForForeignSource( final Class<T> pluginClass, final String foreignSourceName) { final ForeignSource foreignSource = m_foreignSourceRepository.getForeignSource(foreignSourceName); assertNotNull(foreignSource, "Expected a foreignSource with name %s", foreignSourceName); final List<PluginConfig> configs = foreignSource.getPolicies(); if (configs == null) { return Collections.emptyList(); } final List<T> plugins = new ArrayList<T>(configs.size()); for (final PluginConfig config : configs) { final T plugin = m_pluginRegistry.getPluginInstance(pluginClass, config); if (plugin == null) { LogUtils.tracef( this, "Configured plugin is not appropropriate for policy class %s: %s", pluginClass, config); } else { plugins.add(plugin); } } return plugins; }
private ForeignSource createForeignSource(String foreignSource) throws Exception { ForeignSource fs = new ForeignSource(foreignSource); fs.addDetector( new PluginConfig("HTTP", "org.opennms.netmgt.provision.detector.simple.HttpDetector")); fs.addPolicy( new PluginConfig( "all-ipinterfaces", "org.opennms.netmgt.provision.persist.policies.InclusiveInterfacePolicy")); m_foreignSourceRepository.save(fs); m_foreignSourceRepository.flush(); return fs; }
@Test public void integrationTest() { /* * First, the user creates a requisition in the UI, or RESTful * interface. */ Requisition pendingReq = new Requisition("test"); pendingReq.putNode(createNode("1")); m_pending.save(pendingReq); m_pending.flush(); /* * Then, the user makes a foreign source configuration to go along * with that requisition. */ ForeignSource pendingSource = m_repository.getForeignSource("test"); assertTrue(pendingSource.isDefault()); pendingSource.setDetectors(new ArrayList<PluginConfig>()); m_pending.save(pendingSource); m_pending.flush(); /* * Now we got an import event, so we import that requisition file, * and save it. The ForeignSource in the pending repository should * match the one in the active one, now. */ Requisition activeReq = m_repository.importResourceRequisition( new UrlResource(m_pending.getRequisitionURL("test"))); ForeignSource activeSource = m_active.getForeignSource("test"); // and the foreign source should be the same as the one we made earlier, only this time it's // active assertEquals(activeSource.getName(), pendingSource.getName()); assertEquals(activeSource.getDetectorNames(), pendingSource.getDetectorNames()); assertEquals(activeSource.getScanInterval(), pendingSource.getScanInterval()); assertRequisitionsMatch("active and pending requisitions should match", activeReq, pendingReq); /* * Since it's been officially deployed, the requisition and foreign * source should no longer be in the pending repo. */ assertNull( "the requisition should be null in the pending repo", m_pending.getRequisition("test")); assertTrue( "the foreign source should be default since there's no specific in the pending repo", m_pending.getForeignSource("test").isDefault()); }
@Test public void testForeignSource() throws Exception { createRequisition(); ForeignSource foreignSource = createForeignSource(m_defaultForeignSourceName); Set<ForeignSource> foreignSources = m_foreignSourceRepository.getForeignSources(); assertEquals("number of foreign sources must be 1", 1, foreignSources.size()); assertEquals( "getAll() foreign source name must match", m_defaultForeignSourceName, foreignSources.iterator().next().getName()); // check that the foreign source matches final ForeignSource newForeignSource = m_foreignSourceRepository.getForeignSource(m_defaultForeignSourceName); assertEquals(foreignSource.getName(), newForeignSource.getName()); assertEquals(foreignSource.getDateStampAsDate(), newForeignSource.getDateStampAsDate()); assertEquals(foreignSource.getDetectorNames(), newForeignSource.getDetectorNames()); assertEquals(foreignSource.getScanInterval(), newForeignSource.getScanInterval()); }
@Test public void testDefaultForeignSource() throws Exception { createRequisition(); List<String> detectorList = Arrays.asList( new String[] { "DNS", "FTP", "HTTP", "HTTPS", "ICMP", "IMAP", "LDAP", "NRPE", "POP3", "SMTP", "SNMP", "SSH" }); String uuid = UUID.randomUUID().toString(); ForeignSource defaultForeignSource = m_foreignSourceRepository.getForeignSource(uuid); assertEquals( "name must match requested foreign source repository name", uuid, defaultForeignSource.getName()); assertEquals( "scan-interval must be 1 day", 86400000, defaultForeignSource.getScanInterval().getMillis()); assertEquals( "foreign source must have no default policies", 0, defaultForeignSource.getPolicies().size()); List<String> fsNames = new ArrayList<String>(); for (PluginConfig config : defaultForeignSource.getDetectors()) { fsNames.add(config.getName()); } assertEquals("detector list must match expected defaults", detectorList, fsNames); assertTrue("foreign source must be tagged as default", defaultForeignSource.isDefault()); }
private synchronized void cleanUpDeployedForeignSources(String foreignSourceName) { ForeignSource deployed = m_deployedForeignSourceRepository.getForeignSource(foreignSourceName); ForeignSource pending = m_pendingForeignSourceRepository.getForeignSource(foreignSourceName); if (pending.isDefault()) { // if pending is default, assume deployed is valid, be it default or otherwise m_pendingForeignSourceRepository.delete(pending); } else { if (deployed.isDefault()) { // if pending is not default, and deployed is, assume pending should override deployed m_deployedForeignSourceRepository.save(pending); } else { // otherwise, compare dates, pending updates deployed if it's timestamp is newer Date pendingDate = pending.getDateStampAsDate(); Date deployedDate = deployed.getDateStampAsDate(); if (!deployedDate.after(pendingDate)) { m_deployedForeignSourceRepository.save(pending); } } } m_pendingForeignSourceRepository.delete(pending); }