コード例 #1
0
 /**
  * Update 'global' JMS clients and RDB
  *
  * @param pv Alarm PV
  * @param severity Alarm severity (highest, latched)
  * @param message Alarm message
  * @param value Value that triggered
  * @param timestamp Time of last alarm update
  */
 public void sendGlobalUpdate(
     final AlarmPV pv,
     final SeverityLevel severity,
     final String message,
     final String value,
     final Timestamp timestamp) {
   // Send to JMS
   messenger.sendGlobalUpdate(pv, severity, message, value, timestamp);
   // Persist global alarm state change in separate queue & thread
   // so that it won't delay the alarm server from updating
   work_queue.execute(
       new Runnable() {
         @Override
         public void run() {
           try {
             rdb.writeGlobalUpdate(pv, severity.isActive());
             recoverFromRDBErrors();
           } catch (Exception ex) {
             // Remember that there was an error
             had_RDB_error = true;
             Activator.getLogger().log(Level.SEVERE, "Exception during global alarm update", ex);
           }
         }
       });
 }
コード例 #2
0
  /**
   * Update JMS clients and RDB
   *
   * @param pv Alarm PV
   * @param current_severity Current channel severity
   * @param current_message Current message
   * @param severity Alarm severity (highest, latched)
   * @param message Alarm message
   * @param value Value that triggered
   * @param timestamp Time of last alarm update
   */
  public void sendStateUpdate(
      final AlarmPV pv,
      final SeverityLevel current_severity,
      final String current_message,
      final SeverityLevel severity,
      final String message,
      final String value,
      final Timestamp timestamp) {
    messenger.sendStateUpdate(
        pv, current_severity, current_message, severity, message, value, timestamp);
    // Move the persistence of states into separate queue & thread
    // so that it won't delay the alarm server from updating.

    // ReplacableRunnable:
    // If there is already an update request for this PV on the queue,
    // replace it with the new one because it's out of date and no
    // longer needs to be writting to the RDB anyway.
    work_queue.executeReplacable(
        new ReplacableRunnable<AlarmPV>(pv) {
          @Override
          public void run() {
            try {
              rdb.writeStateUpdate(
                  pv, current_severity, current_message, severity, message, value, timestamp);
              recoverFromRDBErrors();
            } catch (Exception ex) {
              // Remember that there was an error
              had_RDB_error = true;
              Activator.getLogger().log(Level.SEVERE, "Exception during alarm state update", ex);
            }
          }
        });
  }
コード例 #3
0
  /** Invoked for received messages */
  private void handleMapMessage(final MapMessage message) {
    try {
      final String text = message.getString(JMSLogMessage.TEXT);
      Runnable action = null;

      // Create action, or handle the message right away

      // Alarm state change?
      if (JMSAlarmMessage.TEXT_STATE.equals(text)) {
        // Received a state update from server, reset timeout
        timeout_timer.reset();
        action = new UpdateAction(AlarmUpdateInfo.fromMapMessage(message));
        model.updateServerState(false);
      } else if (JMSAlarmMessage.TEXT_STATE_MAINTENANCE.equals(text)) {
        timeout_timer.reset();
        action = new UpdateAction(AlarmUpdateInfo.fromMapMessage(message));
        model.updateServerState(true);
      }
      // Idle messages in absence of 'real' traffic?
      else if (JMSAlarmMessage.TEXT_IDLE.equals(text)) {
        timeout_timer.reset();
        model.updateServerState(false);
      } else if (JMSAlarmMessage.TEXT_IDLE_MAINTENANCE.equals(text)) {
        timeout_timer.reset();
        model.updateServerState(true);
      }
      // Enable/disable?
      else if (JMSAlarmMessage.TEXT_ENABLE.equals(text)) {
        timeout_timer.reset();
        final String name = message.getString(JMSLogMessage.NAME);
        action = new EnableAction(name, true);
      } else if (JMSAlarmMessage.TEXT_DISABLE.equals(text)) {
        timeout_timer.reset();
        final String name = message.getString(JMSLogMessage.NAME);
        action = new EnableAction(name, false);
      }
      // Configuration change
      else if (JMSAlarmMessage.TEXT_CONFIG.equals(text)) {
        final String name = message.getString(JMSLogMessage.NAME);
        model.readConfig(name);
      }
      // Debug trigger
      else if (JMSAlarmMessage.TEXT_DEBUG.equals(text)) model.dump();

      if (action == null) return;
      // Queue or dispatch?
      synchronized (queue) {
        if (use_queue) {
          queue.execute(action);
          return;
        }
      }
      // else: Not using queue, and queue no longer locked
      action.run();
    } catch (Throwable ex) {
      Activator.getLogger().log(Level.SEVERE, "Message handler error", ex);
    }
  }
コード例 #4
0
  /**
   * If this is the first successful RDB update after errors, tell everybody to re-load the
   * configuration because otherwise they get out of sync.
   *
   * @throws Exception on error
   */
  protected void recoverFromRDBErrors() throws Exception {
    if (!had_RDB_error) return;

    // We should be on the work queue thread
    work_queue.assertOnThread();
    Activator.getLogger().info("RDB connection recovered, re-loading configuration");
    updateConfig(null);

    // If that worked out, reset error and inform clients
    had_RDB_error = false;
    messenger.sendReloadMessage();
  }
コード例 #5
0
 /**
  * Update JMS clients and RDB about 'enabled' state of PV
  *
  * @param pv Alarm PV
  * @param enabled Enabled or not?
  */
 public void sendEnablementUpdate(final AlarmPV pv, final boolean enabled) {
   messenger.sendEnablementUpdate(pv, enabled);
   // Handle in separate queue & thread
   work_queue.execute(
       new Runnable() {
         @Override
         public void run() {
           try {
             rdb.writeEnablementUpdate(pv, enabled);
             recoverFromRDBErrors();
           } catch (Exception ex) {
             // Remember that there was an error
             had_RDB_error = true;
             Activator.getLogger().log(Level.SEVERE, "Exception during enablement update", ex);
           }
         }
       });
 }
コード例 #6
0
  /** Dump all PVs to stdout */
  public void dump() {
    System.out.println("== Alarm Server PV Snapshot ==");
    synchronized (this) {
      alarm_tree.dump(System.out);
    }

    System.out.println("Work queue size: " + work_queue.size());

    // Log memory usage in MB
    final double free = Runtime.getRuntime().freeMemory() / (1024.0 * 1024.0);
    final double total = Runtime.getRuntime().totalMemory() / (1024.0 * 1024.0);
    final double max = Runtime.getRuntime().maxMemory() / (1024.0 * 1024.0);

    final DateFormat format = new SimpleDateFormat(JMSLogMessage.DATE_FORMAT);
    System.out.format(
        "%s == Alarm Server Memory: Max %.2f MB, Free %.2f MB (%.1f %%), total %.2f MB (%.1f %%)\n",
        format.format(new Date()), max, free, 100.0 * free / max, total, 100.0 * total / max);
  }
コード例 #7
0
 /**
  * Dispatch queued events, or directly dispatch received events?
  *
  * <p>While reading model information, queue mode should be enabled. Then, after model information
  * from RDB has been obtained, disable queue mode which also dispatched all the queued up events.
  *
  * @param use_queue <code>true</code> to queue
  */
 public void setQueueMode(final boolean use_queue) {
   this.use_queue = use_queue;
   if (use_queue) return;
   // Queuing turned off -> Dispatched what has accumulated until now
   queue.performQueuedCommands();
 }