private void doSql(String contents) {
if (getSql() == null) {
LOG.info("send: optional sql argument is null.");
return;
}
if (contents == null) {
LOG.info("doSql: HTTP reply is null");
return;
}
LOG.debug("send: compiling expression: {}", getSwitchValue("result-match"));
Pattern p = Pattern.compile(getSwitchValue("result-match"));
Matcher m = p.matcher(contents);
if (m.matches()) {
LOG.debug("send: compiled expression ready to run sql: {}", getSql());
MatchTable matches = new MatchTable(m);
String sqlString = PropertiesUtils.substitute(getSql(), matches);
LOG.debug("send: running sql: {}", sqlString);
JdbcTemplate template = new JdbcTemplate(DataSourceFactory.getInstance());
template.execute(sqlString);
} else {
LOG.info("send: result didn't match, not running sql");
}
}
/**
* {@inheritDoc}
*
* <p>Initialize the service collector.
*
* <p>During initialization the JMX collector: - Initializes various configuration factories. -
* Verifies access to the database - Verifies access to RRD file repository - Verifies access to
* JNI RRD shared library - Determines if JMX to be stored for only the node's primary interface
* or for all interfaces.
*
* @exception RuntimeException Thrown if an unrecoverable error occurs that prevents the plug-in
* from functioning.
*/
@Override
public void initialize(Map<String, String> parameters) {
// Initialize the JMXDataCollectionConfigFactory
try {
// XXX was reload(), which isn't test-friendly
JMXDataCollectionConfigFactory.init();
} catch (Throwable e) {
LogUtils.errorf(this, e, "initialize: Failed to load data collection configuration");
throw new UndeclaredThrowableException(e);
}
// Make sure we can connect to the database
java.sql.Connection ctest = null;
try {
DataSourceFactory.init();
ctest = DataSourceFactory.getInstance().getConnection();
} catch (final Exception e) {
LogUtils.errorf(this, e, "initialize: failed to get a database connection");
throw new UndeclaredThrowableException(e);
} finally {
if (ctest != null) {
try {
ctest.close();
} catch (final Throwable t) {
LogUtils.debugf(
this, "initialize: an exception occured while closing the JDBC connection");
}
}
}
// Save local reference to singleton instance
LogUtils.debugf(this, "initialize: successfully instantiated JNI interface to RRD.");
}
/** onInit */
@Override
protected void onInit() {
EventIpcManagerFactory.init();
EventIpcManager mgr = EventIpcManagerFactory.getIpcManager();
PassiveStatusKeeper keeper = getPassiveStatusKeeper();
keeper.setEventManager(mgr);
keeper.setDataSource(DataSourceFactory.getInstance());
keeper.init();
}
/**
* This method determines what label should be associated with a particular node. A database
* connection is retrieved from the Vault.
*
* <p>WARNING: A properly instantiated and initialized Vault class object is required prior to
* calling this method. This method will initially only be called from the WEB UI.
*
* @param nodeID Unique identifier of the node to be updated.
* @return NodeLabel Object containing label and source values
* @throws java.sql.SQLException if any.
* @deprecated Update this to use modern DAO methods instead of raw SQL
*/
public NodeLabelJDBCImpl computeLabel(final int nodeID) throws SQLException {
final Connection dbConnection = DataSourceFactory.getInstance().getConnection();
final DBUtils d = new DBUtils(NodeLabelJDBCImpl.class, dbConnection);
try {
return computeLabel(nodeID, null);
} finally {
d.cleanUp();
}
}
/**
* This method updates the 'nodelabel' and 'nodelabelsource' fields of the 'node' table for the
* specified nodeID. A database connection is retrieved from the Vault.
*
* <p>WARNING: A properly instantiated and initialized Vault class object is required prior to
* calling this method. This method will initially only be called from the WEB UI.
*
* @param nodeID Unique identifier of the node to be updated.
* @param nodeLabel Object containing label and source values.
* @throws java.sql.SQLException if any.
* @deprecated Use a {@link NodeDao#update(org.opennms.netmgt.model.OnmsNode)} method call instead
*/
public void assignLabel(final int nodeID, final NodeLabelJDBCImpl nodeLabel) throws SQLException {
final Connection dbConnection = DataSourceFactory.getInstance().getConnection();
final DBUtils d = new DBUtils(NodeLabelJDBCImpl.class, dbConnection);
try {
assignLabel(nodeID, nodeLabel, dbConnection);
} finally {
d.cleanUp();
}
}
/**
* Retrieves a current record from the database based upon the key fields of <em>nodeID</em> and
* <em>ipAddr</em>. If the record cannot be found then a null reference is returned.
*
* @param nid The node id key
* @param addr The ip address.
* @param sid The service id.
* @return The loaded entry or null if one could not be found.
*/
public static DbIfServiceEntry get(int nid, InetAddress addr, int sid) throws SQLException {
Connection db = null;
try {
db = DataSourceFactory.getInstance().getConnection();
return get(db, nid, addr, sid);
} finally {
try {
if (db != null) {
db.close();
}
} catch (SQLException e) {
LOG.warn("Exception closing JDBC connection", e);
}
}
}
/**
* Retrieves a current record from the database based upon the key fields of <em>nodeID</em> and
* <em>ipAddr</em>. If the record cannot be found then a null reference is returned.
*
* @param nid The node id key
* @param addr The ip address.
* @param ifIndex The interface index.
* @return The loaded entry or null if one could not be found.
*/
public static DbIpInterfaceEntry get(int nid, InetAddress addr, int ifIndex) throws SQLException {
Connection db = null;
try {
db = DataSourceFactory.getInstance().getConnection();
return get(db, nid, addr, ifIndex);
} finally {
try {
if (db != null) {
db.close();
}
} catch (SQLException e) {
ThreadCategory.getInstance(DbIpInterfaceEntry.class)
.warn("Exception closing JDBC connection", e);
}
}
}
/**
* Retrieve all the interfaces and services from the database, and keep them in the user session.
*
* @param userSession Current user working session
* @param nodeId Id of the node to manage
*/
private List<ManagedInterface> getInterfaces(HttpSession userSession, int nodeId)
throws SQLException {
Connection connection = null;
List<ManagedInterface> allInterfaces = new ArrayList<ManagedInterface>();
int lineCount = 0;
final DBUtils d = new DBUtils(getClass());
try {
connection = DataSourceFactory.getInstance().getConnection();
d.watch(connection);
PreparedStatement ifaceStmt = connection.prepareStatement(INTERFACE_QUERY);
d.watch(ifaceStmt);
ifaceStmt.setInt(1, nodeId);
ResultSet ifaceResults = ifaceStmt.executeQuery();
d.watch(ifaceResults);
while (ifaceResults.next()) {
lineCount++;
ManagedInterface newInterface = new ManagedInterface();
newInterface.setNodeid(nodeId);
newInterface.setAddress(ifaceResults.getString(1));
newInterface.setStatus(ifaceResults.getString(2));
allInterfaces.add(newInterface);
PreparedStatement svcStmt = connection.prepareStatement(SERVICE_QUERY);
d.watch(svcStmt);
svcStmt.setInt(1, nodeId);
svcStmt.setString(2, newInterface.getAddress());
ResultSet svcResults = svcStmt.executeQuery();
d.watch(svcResults);
while (svcResults.next()) {
lineCount++;
ManagedService newService = new ManagedService();
newService.setId(svcResults.getInt(1));
newService.setName(svcResults.getString(2));
newService.setStatus(svcResults.getString(3));
newInterface.addService(newService);
}
}
userSession.setAttribute("lineItems.nodemanagement", Integer.valueOf(lineCount));
} finally {
d.cleanUp();
}
return allInterfaces;
}
/**
* Updates the interface information in the configured database. If the interfaca does not exist
* the a new row in the table is created. If the element already exists then it's current row is
* updated as needed based upon the current changes to the node.
*/
public void store() throws SQLException {
if (m_changed != 0 || m_fromDb == false) {
Connection db = null;
try {
db = DataSourceFactory.getInstance().getConnection();
store(db);
if (db.getAutoCommit() == false) db.commit();
} finally {
try {
if (db != null) db.close();
} catch (SQLException e) {
LOG.warn("Exception closing JDBC connection", e);
}
}
}
return;
}
public DbIfServiceEntry[] getServices() throws SQLException {
DbIfServiceEntry[] entries = null;
Connection db = null;
try {
db = DataSourceFactory.getInstance().getConnection();
entries = getServices(db);
} finally {
try {
if (db != null) {
db.close();
}
} catch (SQLException e) {
log().warn("Exception closing JDBC connection", e);
}
}
return entries;
}
/**
* getCurrentAssetNodesList
*
* @return a {@link java.util.List} object.
* @throws java.sql.SQLException if any.
*/
public List<Integer> getCurrentAssetNodesList() throws SQLException {
List<Integer> list = new ArrayList<Integer>();
final DBUtils d = new DBUtils(getClass());
try {
Connection conn = DataSourceFactory.getInstance().getConnection();
d.watch(conn);
Statement stmt = conn.createStatement();
d.watch(stmt);
ResultSet rs = stmt.executeQuery("SELECT NODEID FROM ASSETS");
d.watch(rs);
while (rs.next()) {
list.add(Integer.valueOf(rs.getInt("NODEID")));
}
} finally {
d.cleanUp();
}
return list;
}
