@SuppressWarnings({"rawtypes", "unchecked"})
 protected Function<? super Collection<?>, ?> lookupTransformation(String t1) {
   if ("average".equalsIgnoreCase(t1))
     return new Enrichers.ComputingAverage(null, null, targetSensor.getTypeToken());
   if ("sum".equalsIgnoreCase(t1))
     return new Enrichers.ComputingSum(null, null, targetSensor.getTypeToken());
   if ("isQuorate".equalsIgnoreCase(t1))
     return new Enrichers.ComputingIsQuorate(
         targetSensor.getTypeToken(),
         QuorumChecks.of(config().get(QUORUM_CHECK_TYPE)),
         config().get(QUORUM_TOTAL_SIZE));
   if ("list".equalsIgnoreCase(t1)) return new ComputingList();
   return null;
 }
/**
 * Manages the persistence/rebind process.
 *
 * <p>Lifecycle is to create an instance of this, set it up (e.g. {@link
 * #setPeriodicPersistPeriod(Duration)}, {@link #setPersister(BrooklynMementoPersister)}; however
 * noting that persist period must be set before the persister).
 *
 * <p>Usually done for you by the conveniences (such as the launcher).
 */
public class RebindManagerImpl implements RebindManager {

  // TODO Use ImmediateDeltaChangeListener if the period is set to 0?

  public static final ConfigKey<RebindFailureMode> DANGLING_REFERENCE_FAILURE_MODE =
      ConfigKeys.newConfigKey(
          RebindFailureMode.class,
          "rebind.failureMode.danglingRef",
          "Action to take if a dangling reference is discovered during rebind",
          RebindFailureMode.CONTINUE);
  public static final ConfigKey<RebindFailureMode> REBIND_FAILURE_MODE =
      ConfigKeys.newConfigKey(
          RebindFailureMode.class,
          "rebind.failureMode.rebind",
          "Action to take if a failure occurs during rebind",
          RebindFailureMode.FAIL_AT_END);
  public static final ConfigKey<RebindFailureMode> ADD_CONFIG_FAILURE_MODE =
      ConfigKeys.newConfigKey(
          RebindFailureMode.class,
          "rebind.failureMode.addConfig",
          "Action to take if a failure occurs when setting a config value. It could happen coercion of the value type to fail.",
          RebindFailureMode.FAIL_AT_END);
  public static final ConfigKey<RebindFailureMode> ADD_POLICY_FAILURE_MODE =
      ConfigKeys.newConfigKey(
          RebindFailureMode.class,
          "rebind.failureMode.addPolicy",
          "Action to take if a failure occurs when adding a policy or enricher",
          RebindFailureMode.CONTINUE);
  public static final ConfigKey<RebindFailureMode> LOAD_POLICY_FAILURE_MODE =
      ConfigKeys.newConfigKey(
          RebindFailureMode.class,
          "rebind.failureMode.loadPolicy",
          "Action to take if a failure occurs when loading a policy or enricher",
          RebindFailureMode.CONTINUE);

  public static final ConfigKey<QuorumCheck> DANGLING_REFERENCES_MIN_REQUIRED_HEALTHY =
      ConfigKeys.newConfigKey(
          QuorumCheck.class,
          "rebind.failureMode.danglingRefs.minRequiredHealthy",
          "Number of items which must be rebinded at various sizes; "
              + "a small number of dangling references is possible if items are in the process of being created or deleted, "
              + "and that should be resolved on retry; the default set here allows max 2 dangling up to 10 items, "
              + "then linear regression to allow max 5% at 100 items and above",
          QuorumChecks.newLinearRange("[[0,-2],[10,8],[100,95],[200,190]]"));

  public static final Logger LOG = LoggerFactory.getLogger(RebindManagerImpl.class);

  private final ManagementContextInternal managementContext;

  private volatile Duration periodicPersistPeriod = Duration.ONE_SECOND;

  private volatile boolean persistenceRunning = false;
  private volatile PeriodicDeltaChangeListener persistenceRealChangeListener;
  private volatile ChangeListener persistencePublicChangeListener;

  private volatile boolean readOnlyRunning = false;
  private volatile ScheduledTask readOnlyTask = null;
  private transient Semaphore rebindActive = new Semaphore(1);
  private transient AtomicInteger readOnlyRebindCount = new AtomicInteger(Integer.MIN_VALUE);

  private volatile BrooklynMementoPersister persistenceStoreAccess;

  final boolean persistPoliciesEnabled;
  final boolean persistEnrichersEnabled;
  final boolean persistFeedsEnabled;
  final boolean persistCatalogItemsEnabled;

  private RebindFailureMode danglingRefFailureMode;
  private RebindFailureMode rebindFailureMode;
  private RebindFailureMode addConfigFailureMode;
  private RebindFailureMode addPolicyFailureMode;
  private RebindFailureMode loadPolicyFailureMode;
  private QuorumCheck danglingRefsQuorumRequiredHealthy;

  private boolean isAwaitingInitialRebind;

  private PersistenceActivityMetrics rebindMetrics = new PersistenceActivityMetrics();
  private PersistenceActivityMetrics persistMetrics = new PersistenceActivityMetrics();

  Integer firstRebindAppCount, firstRebindEntityCount, firstRebindItemCount;

  /**
   * For tracking if rebinding, for {@link AbstractEnricher#isRebinding()} etc.
   *
   * <p>TODO What is a better way to do this?!
   *
   * @author aled
   */
  @Beta
  public static class RebindTracker {
    private static ThreadLocal<Boolean> rebinding = new ThreadLocal<Boolean>();

    public static boolean isRebinding() {
      return (rebinding.get() == Boolean.TRUE);
    }

    static void reset() {
      rebinding.set(Boolean.FALSE);
    }

    static void setRebinding() {
      rebinding.set(Boolean.TRUE);
    }
  }

  public RebindManagerImpl(ManagementContextInternal managementContext) {
    this.managementContext = managementContext;
    this.persistencePublicChangeListener = ChangeListener.NOOP;

    this.persistPoliciesEnabled =
        BrooklynFeatureEnablement.isEnabled(
            BrooklynFeatureEnablement.FEATURE_POLICY_PERSISTENCE_PROPERTY);
    this.persistEnrichersEnabled =
        BrooklynFeatureEnablement.isEnabled(
            BrooklynFeatureEnablement.FEATURE_ENRICHER_PERSISTENCE_PROPERTY);
    this.persistFeedsEnabled =
        BrooklynFeatureEnablement.isEnabled(
            BrooklynFeatureEnablement.FEATURE_FEED_PERSISTENCE_PROPERTY);
    this.persistCatalogItemsEnabled =
        BrooklynFeatureEnablement.isEnabled(
            BrooklynFeatureEnablement.FEATURE_CATALOG_PERSISTENCE_PROPERTY);

    danglingRefFailureMode =
        managementContext.getConfig().getConfig(DANGLING_REFERENCE_FAILURE_MODE);
    rebindFailureMode = managementContext.getConfig().getConfig(REBIND_FAILURE_MODE);
    addConfigFailureMode = managementContext.getConfig().getConfig(ADD_CONFIG_FAILURE_MODE);
    addPolicyFailureMode = managementContext.getConfig().getConfig(ADD_POLICY_FAILURE_MODE);
    loadPolicyFailureMode = managementContext.getConfig().getConfig(LOAD_POLICY_FAILURE_MODE);

    danglingRefsQuorumRequiredHealthy =
        managementContext.getConfig().getConfig(DANGLING_REFERENCES_MIN_REQUIRED_HEALTHY);

    LOG.debug(
        "{} initialized, settings: policies={}, enrichers={}, feeds={}, catalog={}",
        new Object[] {
          this,
          persistPoliciesEnabled,
          persistEnrichersEnabled,
          persistFeedsEnabled,
          persistCatalogItemsEnabled
        });
  }

  public ManagementContextInternal getManagementContext() {
    return managementContext;
  }

  /** Must be called before setPerister() */
  public void setPeriodicPersistPeriod(Duration period) {
    if (persistenceStoreAccess != null)
      throw new IllegalStateException("Cannot set period after persister is generated.");
    this.periodicPersistPeriod = period;
  }

  /** @deprecated since 0.7.0; use {@link #setPeriodicPersistPeriod(Duration)} */
  public void setPeriodicPersistPeriod(long periodMillis) {
    setPeriodicPersistPeriod(Duration.of(periodMillis, TimeUnit.MILLISECONDS));
  }

  public boolean isPersistenceRunning() {
    return persistenceRunning;
  }

  public boolean isReadOnlyRunning() {
    return readOnlyRunning;
  }

  @Override
  public void setPersister(BrooklynMementoPersister val) {
    PersistenceExceptionHandler exceptionHandler =
        PersistenceExceptionHandlerImpl.builder().build();
    setPersister(val, exceptionHandler);
  }

  @Override
  public void setPersister(
      BrooklynMementoPersister val, PersistenceExceptionHandler exceptionHandler) {
    if (persistenceStoreAccess != null && persistenceStoreAccess != val) {
      throw new IllegalStateException(
          "Dynamically changing persister is not supported: old="
              + persistenceStoreAccess
              + "; new="
              + val);
    }
    if (persistenceRealChangeListener != null) {
      // TODO should probably throw here, but previously we have not -- so let's log for now to be
      // sure it's not happening
      LOG.warn(
          "Persister reset after listeners have been set",
          new Throwable("Source of persister reset"));
    }

    this.persistenceStoreAccess = checkNotNull(val, "persister");

    this.persistenceRealChangeListener =
        new PeriodicDeltaChangeListener(
            managementContext.getServerExecutionContext(),
            persistenceStoreAccess,
            exceptionHandler,
            persistMetrics,
            periodicPersistPeriod);
    this.persistencePublicChangeListener = new SafeChangeListener(persistenceRealChangeListener);

    if (persistenceRunning) {
      persistenceRealChangeListener.start();
    }
  }

  @Override
  @VisibleForTesting
  public BrooklynMementoPersister getPersister() {
    return persistenceStoreAccess;
  }

  @Override
  public void startPersistence() {
    if (readOnlyRunning) {
      throw new IllegalStateException(
          "Cannot start read-only when already running with persistence");
    }
    LOG.debug(
        "Starting persistence (" + this + "), mgmt " + managementContext.getManagementNodeId());
    if (!persistenceRunning) {
      if (managementContext
          .getBrooklynProperties()
          .getConfig(BrooklynServerConfig.PERSISTENCE_BACKUPS_REQUIRED_ON_PROMOTION)) {
        BrooklynPersistenceUtils.createBackup(
            managementContext, CreateBackupMode.PROMOTION, MementoCopyMode.REMOTE);
      }
    }
    persistenceRunning = true;
    readOnlyRebindCount.set(Integer.MIN_VALUE);
    persistenceStoreAccess.enableWriteAccess();
    if (persistenceRealChangeListener != null) persistenceRealChangeListener.start();
  }

  @Override
  public void stopPersistence() {
    LOG.debug(
        "Stopping persistence (" + this + "), mgmt " + managementContext.getManagementNodeId());
    persistenceRunning = false;
    if (persistenceRealChangeListener != null) persistenceRealChangeListener.stop();
    if (persistenceStoreAccess != null) persistenceStoreAccess.disableWriteAccess(true);
    LOG.debug("Stopped rebind (persistence), mgmt " + managementContext.getManagementNodeId());
  }

  @SuppressWarnings("unchecked")
  @Override
  public void startReadOnly(final ManagementNodeState mode) {
    if (!ManagementNodeState.isHotProxy(mode)) {
      throw new IllegalStateException(
          "Read-only rebind thread only permitted for hot proxy modes; not " + mode);
    }

    if (persistenceRunning) {
      throw new IllegalStateException(
          "Cannot start read-only when already running with persistence");
    }
    if (readOnlyRunning || readOnlyTask != null) {
      LOG.warn(
          "Cannot request read-only mode for "
              + this
              + " when already running - "
              + readOnlyTask
              + "; ignoring");
      return;
    }
    LOG.debug(
        "Starting read-only rebinding ("
            + this
            + "), mgmt "
            + managementContext.getManagementNodeId());

    if (persistenceRealChangeListener != null) persistenceRealChangeListener.stop();
    if (persistenceStoreAccess != null) persistenceStoreAccess.disableWriteAccess(true);

    readOnlyRunning = true;
    readOnlyRebindCount.set(0);

    try {
      rebind(null, null, mode);
    } catch (Exception e) {
      throw Exceptions.propagate(e);
    }

    Callable<Task<?>> taskFactory =
        new Callable<Task<?>>() {
          @Override
          public Task<Void> call() {
            return Tasks.<Void>builder()
                .dynamic(false)
                .displayName("rebind (periodic run")
                .body(
                    new Callable<Void>() {
                      public Void call() {
                        try {
                          rebind(null, null, mode);
                          return null;
                        } catch (RuntimeInterruptedException e) {
                          LOG.debug("Interrupted rebinding (re-interrupting): " + e);
                          if (LOG.isTraceEnabled())
                            LOG.trace("Interrupted rebinding (re-interrupting), details: " + e, e);
                          Thread.currentThread().interrupt();
                          return null;
                        } catch (Exception e) {
                          // Don't rethrow: the behaviour of executionManager is different from a
                          // scheduledExecutorService,
                          // if we throw an exception, then our task will never get executed again
                          if (!readOnlyRunning) {
                            LOG.debug(
                                "Problem rebinding (read-only running has probably just been turned off): "
                                    + e);
                            if (LOG.isTraceEnabled()) {
                              LOG.trace(
                                  "Problem rebinding (read-only running has probably just been turned off), details: "
                                      + e,
                                  e);
                            }
                          } else {
                            LOG.error("Problem rebinding: " + Exceptions.collapseText(e), e);
                          }
                          return null;
                        } catch (Throwable t) {
                          LOG.warn("Problem rebinding (rethrowing)", t);
                          throw Exceptions.propagate(t);
                        }
                      }
                    })
                .build();
          }
        };
    readOnlyTask =
        (ScheduledTask)
            managementContext
                .getServerExecutionContext()
                .submit(
                    new ScheduledTask(
                            MutableMap.of("displayName", "Periodic read-only rebind"), taskFactory)
                        .period(periodicPersistPeriod));
  }

  @Override
  public void stopReadOnly() {
    readOnlyRunning = false;
    if (readOnlyTask != null) {
      LOG.debug(
          "Stopping read-only rebinding ("
              + this
              + "), mgmt "
              + managementContext.getManagementNodeId());
      readOnlyTask.cancel(true);
      readOnlyTask.blockUntilEnded();
      boolean reallyEnded = Tasks.blockUntilInternalTasksEnded(readOnlyTask, Duration.TEN_SECONDS);
      if (!reallyEnded) {
        LOG.warn(
            "Rebind (read-only) tasks took too long to die after interrupt (ignoring): "
                + readOnlyTask);
      }
      readOnlyTask = null;
      LOG.debug(
          "Stopped read-only rebinding ("
              + this
              + "), mgmt "
              + managementContext.getManagementNodeId());
    }
  }

  @Override
  public void start() {
    ManagementNodeState target = getRebindMode();
    if (target == ManagementNodeState.HOT_STANDBY || target == ManagementNodeState.HOT_BACKUP) {
      startReadOnly(target);
    } else if (target == ManagementNodeState.MASTER) {
      startPersistence();
    } else {
      LOG.warn("Nothing to start in " + this + " when HA mode is " + target);
    }
  }

  @Override
  public void stop() {
    stopReadOnly();
    stopPersistence();
    if (persistenceStoreAccess != null) persistenceStoreAccess.stop(true);
  }

  public void rebindPartialActive(
      CompoundTransformer transformer, Iterator<BrooklynObject> objectsToRebind) {
    final ClassLoader classLoader = managementContext.getCatalogClassLoader();
    // TODO we might want different exception handling for partials;
    // failure at various points should leave proxies in a sensible state,
    // either pointing at old or at new, though this is relatively untested,
    // and some things e.g. policies might not be properly started
    final RebindExceptionHandler exceptionHandler =
        RebindExceptionHandlerImpl.builder()
            .danglingRefFailureMode(danglingRefFailureMode)
            .danglingRefQuorumRequiredHealthy(danglingRefsQuorumRequiredHealthy)
            .rebindFailureMode(rebindFailureMode)
            .addConfigFailureMode(addConfigFailureMode)
            .addPolicyFailureMode(addPolicyFailureMode)
            .loadPolicyFailureMode(loadPolicyFailureMode)
            .build();
    final ManagementNodeState mode = getRebindMode();

    ActivePartialRebindIteration iteration =
        new ActivePartialRebindIteration(
            this,
            mode,
            classLoader,
            exceptionHandler,
            rebindActive,
            readOnlyRebindCount,
            rebindMetrics,
            persistenceStoreAccess);

    iteration.setObjectIterator(
        Iterators.transform(
            objectsToRebind,
            new Function<BrooklynObject, BrooklynObject>() {
              @Override
              public BrooklynObject apply(BrooklynObject obj) {
                // entities must be deproxied
                if (obj instanceof Entity) obj = Entities.deproxy((Entity) obj);
                return obj;
              }
            }));
    if (transformer != null) iteration.applyTransformer(transformer);
    iteration.run();
  }

  public void rebindPartialActive(CompoundTransformer transformer, String... objectsToRebindIds) {
    List<BrooklynObject> objectsToRebind = MutableList.of();
    for (String objectId : objectsToRebindIds) {
      BrooklynObject obj = managementContext.lookup(objectId);
      objectsToRebind.add(obj);
    }
    rebindPartialActive(transformer, objectsToRebind.iterator());
  }

  protected ManagementNodeState getRebindMode() {
    if (managementContext == null)
      throw new IllegalStateException("Invalid " + this + ": no management context");
    if (!(managementContext.getHighAvailabilityManager() instanceof HighAvailabilityManagerImpl))
      throw new IllegalStateException(
          "Invalid "
              + this
              + ": unknown HA manager type "
              + managementContext.getHighAvailabilityManager());
    ManagementNodeState target =
        ((HighAvailabilityManagerImpl) managementContext.getHighAvailabilityManager())
            .getTransitionTargetNodeState();
    return target;
  }

  @Override
  @VisibleForTesting
  public void waitForPendingComplete(Duration timeout, boolean canTrigger)
      throws InterruptedException, TimeoutException {
    if (persistenceStoreAccess == null || !persistenceRunning) return;
    persistenceRealChangeListener.waitForPendingComplete(timeout, canTrigger);
    persistenceStoreAccess.waitForWritesCompleted(timeout);
  }

  @Override
  @VisibleForTesting
  public void forcePersistNow() {
    forcePersistNow(false, null);
  }

  @Override
  @VisibleForTesting
  public void forcePersistNow(boolean full, PersistenceExceptionHandler exceptionHandler) {
    if (full) {
      BrooklynMementoRawData memento =
          BrooklynPersistenceUtils.newStateMemento(managementContext, MementoCopyMode.LOCAL);
      if (exceptionHandler == null) {
        exceptionHandler = persistenceRealChangeListener.getExceptionHandler();
      }
      persistenceStoreAccess.checkpoint(memento, exceptionHandler);
    } else {
      if (!persistenceRealChangeListener.persistNowSafely()) {
        throw new IllegalStateException("Forced persistence failed; see logs fore more detail");
      }
    }
  }

  @Override
  public ChangeListener getChangeListener() {
    return persistencePublicChangeListener;
  }

  @Override
  public List<Application> rebind() {
    return rebind(null, null, null);
  }

  @Override
  public List<Application> rebind(final ClassLoader classLoader) {
    return rebind(classLoader, null, null);
  }

  @Override
  public List<Application> rebind(
      final ClassLoader classLoader, final RebindExceptionHandler exceptionHandler) {
    return rebind(classLoader, exceptionHandler, null);
  }

  @Override
  public List<Application> rebind(
      ClassLoader classLoaderO,
      RebindExceptionHandler exceptionHandlerO,
      ManagementNodeState modeO) {
    final ClassLoader classLoader =
        classLoaderO != null ? classLoaderO : managementContext.getCatalogClassLoader();
    final RebindExceptionHandler exceptionHandler =
        exceptionHandlerO != null
            ? exceptionHandlerO
            : RebindExceptionHandlerImpl.builder()
                .danglingRefFailureMode(danglingRefFailureMode)
                .danglingRefQuorumRequiredHealthy(danglingRefsQuorumRequiredHealthy)
                .rebindFailureMode(rebindFailureMode)
                .addConfigFailureMode(addConfigFailureMode)
                .addPolicyFailureMode(addPolicyFailureMode)
                .loadPolicyFailureMode(loadPolicyFailureMode)
                .build();
    final ManagementNodeState mode = modeO != null ? modeO : getRebindMode();

    if (mode != ManagementNodeState.MASTER
        && mode != ManagementNodeState.HOT_STANDBY
        && mode != ManagementNodeState.HOT_BACKUP)
      throw new IllegalStateException(
          "Must be either master or hot standby/backup to rebind (mode " + mode + ")");

    ExecutionContext ec = BasicExecutionContext.getCurrentExecutionContext();
    if (ec == null) {
      ec = managementContext.getServerExecutionContext();
      Task<List<Application>> task =
          ec.submit(
              new Callable<List<Application>>() {
                @Override
                public List<Application> call() throws Exception {
                  return rebindImpl(classLoader, exceptionHandler, mode);
                }
              });
      try {
        return task.get();
      } catch (Exception e) {
        throw Exceptions.propagate(e);
      }
    } else {
      return rebindImpl(classLoader, exceptionHandler, mode);
    }
  }

  @Override
  public BrooklynMementoRawData retrieveMementoRawData() {
    RebindExceptionHandler exceptionHandler =
        RebindExceptionHandlerImpl.builder()
            .danglingRefFailureMode(danglingRefFailureMode)
            .rebindFailureMode(rebindFailureMode)
            .addConfigFailureMode(addConfigFailureMode)
            .addPolicyFailureMode(addPolicyFailureMode)
            .loadPolicyFailureMode(loadPolicyFailureMode)
            .build();

    return loadMementoRawData(exceptionHandler);
  }

  /**
   * Uses the persister to retrieve (and thus deserialize) the memento.
   *
   * <p>In so doing, it instantiates the entities + locations, registering them with the
   * rebindContext.
   */
  protected BrooklynMementoRawData loadMementoRawData(
      final RebindExceptionHandler exceptionHandler) {
    try {
      if (persistenceStoreAccess == null) {
        throw new IllegalStateException(
            "Persistence not configured; cannot load memento data from persistent backing store");
      }
      if (!(persistenceStoreAccess instanceof BrooklynMementoPersisterToObjectStore)) {
        throw new IllegalStateException(
            "Cannot load raw memento with persister " + persistenceStoreAccess);
      }

      return ((BrooklynMementoPersisterToObjectStore) persistenceStoreAccess)
          .loadMementoRawData(exceptionHandler);

    } catch (RuntimeException e) {
      throw exceptionHandler.onFailed(e);
    }
  }

  protected List<Application> rebindImpl(
      final ClassLoader classLoader,
      final RebindExceptionHandler exceptionHandler,
      ManagementNodeState mode) {
    RebindIteration iteration =
        new InitialFullRebindIteration(
            this,
            mode,
            classLoader,
            exceptionHandler,
            rebindActive,
            readOnlyRebindCount,
            rebindMetrics,
            persistenceStoreAccess);

    iteration.run();

    if (firstRebindAppCount == null) {
      firstRebindAppCount = iteration.getApplications().size();
      firstRebindEntityCount = iteration.getRebindContext().getEntities().size();
      firstRebindItemCount = iteration.getRebindContext().getAllBrooklynObjects().size();
    }
    isAwaitingInitialRebind = false;

    return iteration.getApplications();
  }

  /**
   * Sorts the map of nodes, so that a node's parent is guaranteed to come before that node (unless
   * the parent is missing).
   *
   * <p>Relies on ordering guarantees of returned map (i.e. LinkedHashMap, which guarantees
   * insertion order even if a key is re-inserted into the map).
   *
   * <p>TODO Inefficient implementation!
   */
  @VisibleForTesting
  static <T extends TreeNode> Map<String, T> sortParentFirst(Map<String, T> nodes) {
    Map<String, T> result = Maps.newLinkedHashMap();
    for (T node : nodes.values()) {
      List<T> tempchain = Lists.newLinkedList();

      T nodeinchain = node;
      while (nodeinchain != null) {
        tempchain.add(0, nodeinchain);
        nodeinchain = (nodeinchain.getParent() == null) ? null : nodes.get(nodeinchain.getParent());
      }
      for (T n : tempchain) {
        result.put(n.getId(), n);
      }
    }
    return result;
  }

  public boolean isAwaitingInitialRebind() {
    return isAwaitingInitialRebind;
  }

  public void setAwaitingInitialRebind(boolean isAwaitingInitialRebind) {
    this.isAwaitingInitialRebind = isAwaitingInitialRebind;
  }

  /**
   * Wraps a ChangeListener, to log and never propagate any exceptions that it throws.
   *
   * <p>Catches Throwable, because really don't want a problem to propagate up to user code, to
   * cause business-level operations to fail. For example, if there is a linkage error due to some
   * problem in the serialization dependencies then just log it. For things more severe (e.g.
   * OutOfMemoryError) then the catch+log means we'll report that we failed to persist, and we'd
   * expect other threads to throw the OutOfMemoryError so we shouldn't lose anything.
   */
  private static class SafeChangeListener implements ChangeListener {
    private final ChangeListener delegate;

    public SafeChangeListener(ChangeListener delegate) {
      this.delegate = delegate;
    }

    @Override
    public void onManaged(BrooklynObject instance) {
      try {
        delegate.onManaged(instance);
      } catch (Throwable t) {
        LOG.error("Error persisting mememento onManaged(" + instance + "); continuing.", t);
      }
    }

    @Override
    public void onChanged(BrooklynObject instance) {
      try {
        delegate.onChanged(instance);
      } catch (Throwable t) {
        LOG.error("Error persisting mememento onChanged(" + instance + "); continuing.", t);
      }
    }

    @Override
    public void onUnmanaged(BrooklynObject instance) {
      try {
        delegate.onUnmanaged(instance);
      } catch (Throwable t) {
        LOG.error("Error persisting mememento onUnmanaged(" + instance + "); continuing.", t);
      }
    }
  }

  public int getReadOnlyRebindCount() {
    return readOnlyRebindCount.get();
  }

  @Override
  public Map<String, Object> getMetrics() {
    Map<String, Object> result = MutableMap.of();

    result.put("rebind", rebindMetrics.asMap());
    result.put("persist", persistMetrics.asMap());

    if (readOnlyRebindCount.get() >= 0) result.put("rebindReadOnlyCount", readOnlyRebindCount);

    // include first rebind counts, so we know whether we rebinded or not
    result.put(
        "firstRebindCounts",
        MutableMap.of(
            "applications", firstRebindAppCount,
            "entities", firstRebindEntityCount,
            "allItems", firstRebindItemCount));

    return result;
  }

  @Override
  public String toString() {
    return super.toString() + "[mgmt=" + managementContext.getManagementNodeId() + "]";
  }
}