/**
   * init
   *
   * @throws javax.servlet.ServletException if any.
   */
  @Override
  public void init() throws ServletException {
    ServletConfig config = this.getServletConfig();
    try {
      props.load(
          new FileInputStream(
              ConfigFileConstants.getFile(ConfigFileConstants.POLLER_CONF_FILE_NAME)));
      PollerConfigFactory.init();
      pollerFactory = PollerConfigFactory.getInstance();
      pollerConfig = pollerFactory.getConfiguration();

      if (pollerConfig == null) {
        throw new ServletException("Poller Configuration file is empty");
      }
      CapsdConfigFactory.init();
      capsdFactory = CapsdConfigFactory.getInstance();
      capsdConfig = capsdFactory.getConfiguration();

      if (capsdConfig == null) {
        throw new ServletException("Poller Configuration file is empty");
      }
    } catch (Throwable e) {
      throw new ServletException(e.getMessage());
    }
    initPollerServices();
    initCapsdProtocols();
    this.redirectSuccess = config.getInitParameter("redirect.success");
    if (this.redirectSuccess == null) {
      throw new ServletException("Missing required init parameter: redirect.success");
    }
  }
 private boolean isServicePolledLocally(
     final String ifAddr,
     final String svcName,
     final org.opennms.netmgt.config.poller.Package ipPkg) {
   boolean svcToBePolled = false;
   if (ipPkg != null && !ipPkg.getRemote()) {
     final PollerConfig pollerConfig = getPollerConfig();
     pollerConfig.getReadLock().lock();
     try {
       svcToBePolled = pollerConfig.isPolled(svcName, ipPkg);
       if (!svcToBePolled) svcToBePolled = pollerConfig.isPolledLocally(ifAddr, svcName);
     } finally {
       pollerConfig.getReadLock().unlock();
     }
   }
   return svcToBePolled;
 }
  /**
   * syncManagementState
   *
   * @param conn a {@link java.sql.Connection} object.
   * @throws java.sql.SQLException if any.
   */
  public void syncManagementState(Connection conn) throws SQLException {
    boolean verifyServer = getOpennmsServerConfig().verifyServer();
    String localServer = getOpennmsServerConfig().getServerName();

    if (log().isDebugEnabled()) {
      log()
          .debug(
              "syncManagementState: local server: "
                  + localServer
                  + " verify server: "
                  + verifyServer);
    }

    if (conn == null) {
      log()
          .error(
              "CapsdConfigFactory.syncManagementState: Sync failed...must have valid database connection.");
      return;
    }

    // Get default management state.
    //
    String managementPolicy = getCapsdConfig().getConfiguration().getManagementPolicy();
    boolean managedByDefault =
        (managementPolicy == null || managementPolicy.equalsIgnoreCase("managed"));
    if (log().isDebugEnabled()) {
      log().debug("syncManagementState: managed_by_default: " + managedByDefault);
    }

    //
    // Retrieve list of interfaces and their managed status from the
    // database
    // NOTE: Interfaces with an 'isManaged' field equal to 'D' (Deleted) or
    // 'F' (Forced Unmanaged) are
    // not eligible to be managed and will not be included in the interfaces
    // retrieved from the database. Likewise, interfaces with IP address of
    // '0.0.0.0' will also be excluded by the SQL query.
    //

    // prepare the SQL statement to query the database
    PreparedStatement ipRetStmt = null;
    final DBUtils d = new DBUtils(getClass());
    List<LightWeightIfEntry> ifList = new ArrayList<LightWeightIfEntry>();

    try {
      if (verifyServer) {
        ipRetStmt = conn.prepareStatement(SQL_DB_RETRIEVE_IP_INTERFACE_IN_LOCAL_SERVER);
        d.watch(ipRetStmt);
        ipRetStmt.setString(1, localServer);
      } else {
        ipRetStmt = conn.prepareStatement(SQL_DB_RETRIEVE_IP_INTERFACE);
        d.watch(ipRetStmt);
      }

      ResultSet result = null;

      // run the statement
      result = ipRetStmt.executeQuery();
      d.watch(result);

      // Build array list of CapsdInterface objects representing each
      // of the interfaces retrieved from the database
      while (result.next()) {
        // Node Id
        int nodeId = result.getInt(1);

        // IP address
        String address = result.getString(2);
        if (address == null) {
          log().warn("invalid ipInterface table entry, no IP address, skipping...");
          continue;
        }

        // Management State
        char managedState = DbIpInterfaceEntry.STATE_UNKNOWN;
        String str = result.getString(3);
        if (str != null) {
          managedState = str.charAt(0);
        }

        ifList.add(
            new LightWeightIfEntry(
                nodeId,
                LightWeightIfEntry.NULL_IFINDEX,
                address,
                managedState,
                DbIpInterfaceEntry.SNMP_UNKNOWN,
                LightWeightIfEntry.NULL_IFTYPE));
      }
    } finally {
      d.cleanUp();
    }

    try {
      // For efficiency, prepare the SQL statements in advance
      PreparedStatement ifUpdateStmt = conn.prepareStatement(SQL_DB_UPDATE_IP_INTERFACE);
      d.watch(ifUpdateStmt);
      PreparedStatement allSvcUpdateStmt =
          conn.prepareStatement(SQL_DB_UPDATE_ALL_SERVICES_FOR_NIP);
      d.watch(allSvcUpdateStmt);
      PreparedStatement svcRetStmt = conn.prepareStatement(SQL_DB_RETRIEVE_IF_SERVICES);
      d.watch(svcRetStmt);
      PreparedStatement svcUpdateStmt = conn.prepareStatement(SQL_DB_UPDATE_SERVICE_FOR_NIP);
      d.watch(svcUpdateStmt);

      /*
       * Loop through interface list and determine if there has been a
       * change in the managed status of the interface based on the
       * newly loaded package configuration data.
       */
      for (LightWeightIfEntry ifEntry : ifList) {
        String ipaddress = ifEntry.getAddress();

        // Convert to InetAddress object
        InetAddress ifAddress = null;
        ifAddress = InetAddressUtils.addr(ipaddress);
        if (ifAddress == null) {
          log().warn("Failed converting ip address " + ipaddress + " to InetAddress.");
          continue;
        }

        // Check interface address against Capsd config information to
        // determine
        // if interface management state should be managed or unmanaged.
        boolean address_is_unmanaged = getCapsdConfig().isAddressUnmanaged(ifAddress);
        if (log().isDebugEnabled()) {
          log()
              .debug(
                  "syncManagementState: "
                      + ipaddress
                      + " unmanaged based on capsd config?: "
                      + address_is_unmanaged);
        }

        if (address_is_unmanaged) {
          // Interface not managed, check current
          // management state for this interface.
          if (ifEntry.getManagementState() != DbIpInterfaceEntry.STATE_UNMANAGED) {
            // Update management state to unmanaged for the
            // interface as well as for its services.

            // Update the 'ipInterface' table
            ifUpdateStmt.setString(1, new String(new char[] {DbIpInterfaceEntry.STATE_UNMANAGED}));
            ifUpdateStmt.setInt(2, ifEntry.getNodeId());
            ifUpdateStmt.setString(3, ipaddress);
            ifUpdateStmt.executeUpdate();

            // Update the 'ifServices' table
            allSvcUpdateStmt.setString(
                1, new String(new char[] {DbIfServiceEntry.STATUS_UNMANAGED}));
            allSvcUpdateStmt.setInt(2, ifEntry.getNodeId());
            allSvcUpdateStmt.setString(3, ipaddress);
            allSvcUpdateStmt.executeUpdate();

            if (log().isDebugEnabled()) {
              log()
                  .debug(
                      "syncManagementState: update completed for node/interface: "
                          + ifEntry.getNodeId()
                          + "/"
                          + ipaddress
                          + " to unmanaged");
            }
          }
        } else {
          /*
           * Interface should be managed - check the status against
           * poller config to see if interface will be polled
           *
           * NOTE: Try to avoid re-evaluating the ip against filters
           * for each service, try to get the first package here and
           * for that for service evaluation
           */
          final PollerConfig pollerConfig = getPollerConfig();
          pollerConfig.getReadLock().lock();
          try {
            org.opennms.netmgt.config.poller.Package ipPkg =
                pollerConfig.getFirstPackageMatch(ipaddress);
            boolean ipToBePolled = false;
            if (ipPkg != null) {
              ipToBePolled = true;
            }

            if (log().isDebugEnabled()) {
              log()
                  .debug(
                      "syncManagementState: "
                          + ipaddress
                          + " to be polled based on poller config?: "
                          + ipToBePolled);
            }

            if ((ifEntry.getManagementState() == DbIpInterfaceEntry.STATE_MANAGED && ipToBePolled)
                || (ifEntry.getManagementState() == DbIpInterfaceEntry.STATE_NOT_POLLED
                    && !ipToBePolled)) {
              // current status is right
              if (log().isDebugEnabled()) {
                log().debug("syncManagementState: " + ipaddress + " - no change in status");
              }
            } else {
              if (ipToBePolled) {
                ifUpdateStmt.setString(
                    1, new String(new char[] {DbIpInterfaceEntry.STATE_MANAGED}));
              } else {
                ifUpdateStmt.setString(
                    1, new String(new char[] {DbIpInterfaceEntry.STATE_NOT_POLLED}));
              }

              ifUpdateStmt.setInt(2, ifEntry.getNodeId());
              ifUpdateStmt.setString(3, ipaddress);
              ifUpdateStmt.executeUpdate();

              if (log().isDebugEnabled()) {
                log()
                    .debug(
                        "syncManagementState: update completed for node/interface: "
                            + ifEntry.getNodeId()
                            + "/"
                            + ipaddress);
              }
            }

            // get services for this nodeid/ip and update
            svcRetStmt.setInt(1, ifEntry.getNodeId());
            svcRetStmt.setString(2, ipaddress);

            ResultSet svcRS = svcRetStmt.executeQuery();
            d.watch(svcRS);
            while (svcRS.next()) {
              int svcId = svcRS.getInt(1);

              char svcStatus = DbIfServiceEntry.STATUS_UNKNOWN;
              String str = svcRS.getString(2);
              if (str != null) {
                svcStatus = str.charAt(0);
              }

              String svcName = getServiceName(svcId);
              /*
               * try the first package that had the ip first, if
               * service is not enabled, try all packages
               */
              char oldStatus = svcStatus;
              char newStatus = 'U';
              boolean svcToBePolledLocally = isServicePolledLocally(ipaddress, svcName, ipPkg);
              boolean svcToBePolledRemotely = isServicePolled(ipaddress, svcName, ipPkg);

              if (log().isDebugEnabled()) {
                log()
                    .debug(
                        "syncManagementState: "
                            + ipaddress
                            + "/"
                            + svcName
                            + " to be polled based on poller config?: "
                            + svcToBePolledLocally);
              }

              if ((svcStatus == DbIfServiceEntry.STATUS_ACTIVE && svcToBePolledLocally)
                  || (svcStatus == DbIfServiceEntry.STATUS_NOT_POLLED && !ipToBePolled)) {
                // current status is right
                if (log().isDebugEnabled()) {
                  log()
                      .debug(
                          "syncManagementState: "
                              + ifEntry.getNodeId()
                              + "/"
                              + ipaddress
                              + "/"
                              + svcName
                              + " status = "
                              + svcStatus
                              + " - no change in status");
                }
              } else {
                // Update the 'ifServices' table
                if (svcStatus == DbIfServiceEntry.STATUS_SUSPEND && svcToBePolledLocally) {
                  svcUpdateStmt.setString(
                      1, new String(new char[] {DbIfServiceEntry.STATUS_FORCED}));
                  newStatus = 'F';
                } else if (svcToBePolledLocally) {
                  svcUpdateStmt.setString(
                      1, new String(new char[] {DbIfServiceEntry.STATUS_ACTIVE}));
                  newStatus = 'A';
                } else if (svcToBePolledRemotely) {
                  svcUpdateStmt.setString(
                      1, new String(new char[] {DbIfServiceEntry.STATUS_REMOTE}));
                  newStatus = 'X';
                } else {
                  svcUpdateStmt.setString(
                      1, new String(new char[] {DbIfServiceEntry.STATUS_NOT_POLLED}));
                  newStatus = 'N';
                }
                svcUpdateStmt.setInt(2, ifEntry.getNodeId());
                svcUpdateStmt.setString(3, ipaddress);
                svcUpdateStmt.setInt(4, svcId);
                svcUpdateStmt.executeUpdate();

                if (log().isDebugEnabled()) {
                  log()
                      .debug(
                          "syncManagementState: update completed for node/interface/svc: "
                              + ifEntry.getNodeId()
                              + "/"
                              + ipaddress
                              + "/"
                              + svcName
                              + " status changed from "
                              + oldStatus
                              + " to "
                              + newStatus);
                }
              }
            } // end ifservices result
          } finally {
            pollerConfig.getReadLock().unlock();
          }
        } // interface managed
      } // end while
    } finally {
      d.cleanUp();
    }
  }