@Override
  public void connectSensors() {
    super.connectSensors();
    connectServiceUpIsRunning();

    HostAndPort hostAndPort =
        BrooklynAccessUtils.getBrooklynAccessibleAddress(this, sensors().get(DOCKER_REGISTRY_PORT));
    sensors().set(Attributes.MAIN_URI, URI.create("https://" + hostAndPort + "/v2"));

    httpFeed =
        HttpFeed.builder()
            .entity(this)
            .period(Duration.seconds(3))
            .baseUri(getAttribute(Attributes.MAIN_URI))
            .poll(
                new HttpPollConfig<Boolean>(Attributes.SERVICE_UP)
                    .onSuccess(Functions.constant(true))
                    .onFailureOrException(Functions.constant(false)))
            .poll(
                new HttpPollConfig<List<String>>(DOCKER_REGISTRY_CATALOG)
                    .suburl("/_catalog")
                    .onSuccess(
                        Functionals.chain(
                            HttpValueFunctions.jsonContents(),
                            JsonFunctions.walk("repositories"),
                            JsonFunctions.forEach(JsonFunctions.cast(String.class))))
                    .onFailureOrException(Functions.constant(Collections.<String>emptyList())))
            .build();
  }
 @Override
 public Cidr get() {
   Cidr local = cidr;
   if (local == null) {
     synchronized (this) {
       local = cidr;
       if (local == null) {
         String externalIp = LocalhostExternalIpLoader.getLocalhostIpWithin(Duration.seconds(5));
         cidr = local = new Cidr(externalIp + "/32");
       }
     }
   }
   return local;
 }
  @Override
  public ComputeService findComputeService(ConfigBag conf, boolean allowReuse) {
    String provider = checkNotNull(conf.get(CLOUD_PROVIDER), "provider must not be null");
    String identity =
        checkNotNull(conf.get(CloudLocationConfig.ACCESS_IDENTITY), "identity must not be null");
    String credential =
        checkNotNull(
            conf.get(CloudLocationConfig.ACCESS_CREDENTIAL), "credential must not be null");

    Properties properties = new Properties();
    properties.setProperty(Constants.PROPERTY_TRUST_ALL_CERTS, Boolean.toString(true));
    properties.setProperty(Constants.PROPERTY_RELAX_HOSTNAME, Boolean.toString(true));
    properties.setProperty(
        "jclouds.ssh.max-retries",
        conf.getStringKey("jclouds.ssh.max-retries") != null
            ? conf.getStringKey("jclouds.ssh.max-retries").toString()
            : "50");
    // Enable aws-ec2 lazy image fetching, if given a specific imageId; otherwise customize for
    // specific owners; or all as a last resort
    // See https://issues.apache.org/jira/browse/WHIRR-416
    if ("aws-ec2".equals(provider)) {
      // TODO convert AWS-only flags to config keys
      if (groovyTruth(conf.get(IMAGE_ID))) {
        properties.setProperty(PROPERTY_EC2_AMI_QUERY, "");
        properties.setProperty(PROPERTY_EC2_CC_AMI_QUERY, "");
      } else if (groovyTruth(conf.getStringKey("imageOwner"))) {
        properties.setProperty(
            PROPERTY_EC2_AMI_QUERY,
            "owner-id=" + conf.getStringKey("imageOwner") + ";state=available;image-type=machine");
      } else if (groovyTruth(conf.getStringKey("anyOwner"))) {
        // set `anyOwner: true` to override the default query (which is restricted to certain owners
        // as per below),
        // allowing the AMI query to bind to any machine
        // (note however, we sometimes pick defaults in JcloudsLocationFactory);
        // (and be careful, this can give a LOT of data back, taking several minutes,
        // and requiring extra memory allocated on the command-line)
        properties.setProperty(PROPERTY_EC2_AMI_QUERY, "state=available;image-type=machine");
        /*
         * by default the following filters are applied:
         * Filter.1.Name=owner-id&Filter.1.Value.1=137112412989&
         * Filter.1.Value.2=063491364108&
         * Filter.1.Value.3=099720109477&
         * Filter.1.Value.4=411009282317&
         * Filter.2.Name=state&Filter.2.Value.1=available&
         * Filter.3.Name=image-type&Filter.3.Value.1=machine&
         */
      }

      // occasionally can get com.google.common.util.concurrent.UncheckedExecutionException:
      // java.lang.RuntimeException:
      //     security group eu-central-1/jclouds#brooklyn-bxza-alex-eu-central-shoul-u2jy-nginx-ielm
      // is not available after creating
      // the default timeout was 500ms so let's raise it in case that helps
      properties.setProperty(
          EC2Constants.PROPERTY_EC2_TIMEOUT_SECURITYGROUP_PRESENT,
          "" + Duration.seconds(30).toMilliseconds());
    }

    // FIXME Deprecated mechanism, should have a ConfigKey for overrides
    Map<String, Object> extra =
        Maps.filterKeys(conf.getAllConfig(), Predicates.containsPattern("^jclouds\\."));
    if (extra.size() > 0) {
      LOG.warn("Jclouds using deprecated property overrides: " + Sanitizer.sanitize(extra));
    }
    properties.putAll(extra);

    String endpoint = conf.get(CloudLocationConfig.CLOUD_ENDPOINT);
    if (!groovyTruth(endpoint)) endpoint = getDeprecatedProperty(conf, Constants.PROPERTY_ENDPOINT);
    if (groovyTruth(endpoint)) properties.setProperty(Constants.PROPERTY_ENDPOINT, endpoint);

    Map<?, ?> cacheKey =
        MutableMap.builder()
            .putAll(properties)
            .put("provider", provider)
            .put("identity", identity)
            .put("credential", credential)
            .putIfNotNull("endpoint", endpoint)
            .build()
            .asUnmodifiable();

    if (allowReuse) {
      ComputeService result = cachedComputeServices.get(cacheKey);
      if (result != null) {
        LOG.trace(
            "jclouds ComputeService cache hit for compute service, for "
                + Sanitizer.sanitize(properties));
        return result;
      }
      LOG.debug(
          "jclouds ComputeService cache miss for compute service, creating, for "
              + Sanitizer.sanitize(properties));
    }

    Iterable<Module> modules = getCommonModules();

    // Synchronizing to avoid deadlock from sun.reflect.annotation.AnnotationType.
    // See https://github.com/brooklyncentral/brooklyn/issues/974
    ComputeServiceContext computeServiceContext;
    synchronized (createComputeServicesMutex) {
      computeServiceContext =
          ContextBuilder.newBuilder(provider)
              .modules(modules)
              .credentials(identity, credential)
              .overrides(properties)
              .build(ComputeServiceContext.class);
    }
    final ComputeService computeService = computeServiceContext.getComputeService();
    if (allowReuse) {
      synchronized (cachedComputeServices) {
        ComputeService result = cachedComputeServices.get(cacheKey);
        if (result != null) {
          LOG.debug(
              "jclouds ComputeService cache recovery for compute service, for "
                  + Sanitizer.sanitize(cacheKey));
          // keep the old one, discard the new one
          computeService.getContext().close();
          return result;
        }
        LOG.debug(
            "jclouds ComputeService created "
                + computeService
                + ", adding to cache, for "
                + Sanitizer.sanitize(properties));
        cachedComputeServices.put(cacheKey, computeService);
      }
    }
    return computeService;
  }
public class RebindTestUtils {

  private static final Logger LOG = LoggerFactory.getLogger(RebindTestUtils.class);

  private static final Duration TIMEOUT = Duration.seconds(20);

  public static <T> T serializeAndDeserialize(T memento) throws Exception {
    ObjectReplacer replacer =
        new ObjectReplacer() {
          private final Map<Pointer, Object> replaced = Maps.newLinkedHashMap();

          @Override
          public Object replace(Object toserialize) {
            if (toserialize instanceof Location || toserialize instanceof Entity) {
              Pointer pointer = new Pointer(((Identifiable) toserialize).getId());
              replaced.put(pointer, toserialize);
              return pointer;
            }
            return toserialize;
          }

          @Override
          public Object resolve(Object todeserialize) {
            if (todeserialize instanceof Pointer) {
              return checkNotNull(replaced.get(todeserialize), todeserialize);
            }
            return todeserialize;
          }
        };

    try {
      return Serializers.reconstitute(memento, replacer);
    } catch (Exception e) {
      try {
        Dumpers.logUnserializableChains(memento, replacer);
        // Dumpers.deepDumpSerializableness(memento);
      } catch (Throwable t) {
        LOG.warn(
            "Error logging unserializable chains for memento "
                + memento
                + " (propagating original exception)",
            t);
      }
      throw e;
    }
  }

  public static void deleteMementoDir(String path) {
    deleteMementoDir(new File(path));
  }

  public static void deleteMementoDir(File f) {
    FileBasedObjectStore.deleteCompletely(f);
  }

  public static void checkMementoSerializable(Application app) throws Exception {
    BrooklynMemento memento = MementosGenerators.newBrooklynMemento(app.getManagementContext());
    checkMementoSerializable(memento);
  }

  public static void checkMementoSerializable(BrooklynMemento memento) throws Exception {
    serializeAndDeserialize(memento);
  }

  public static LocalManagementContext newPersistingManagementContext(
      File mementoDir, ClassLoader classLoader) {
    return managementContextBuilder(mementoDir, classLoader).buildStarted();
  }

  public static LocalManagementContext newPersistingManagementContext(
      File mementoDir, ClassLoader classLoader, long persistPeriodMillis) {
    return managementContextBuilder(mementoDir, classLoader)
        .persistPeriodMillis(persistPeriodMillis)
        .buildStarted();
  }

  public static LocalManagementContext newPersistingManagementContextUnstarted(
      File mementoDir, ClassLoader classLoader) {
    return managementContextBuilder(mementoDir, classLoader).buildUnstarted();
  }

  public static ManagementContextBuilder managementContextBuilder(
      File mementoDir, ClassLoader classLoader) {
    return new ManagementContextBuilder(classLoader, mementoDir);
  }

  public static ManagementContextBuilder managementContextBuilder(
      ClassLoader classLoader, File mementoDir) {
    return new ManagementContextBuilder(classLoader, mementoDir);
  }

  public static ManagementContextBuilder managementContextBuilder(
      ClassLoader classLoader, PersistenceObjectStore objectStore) {
    return new ManagementContextBuilder(classLoader, objectStore);
  }

  public static class ManagementContextBuilder {
    final ClassLoader classLoader;
    BrooklynProperties properties;
    PersistenceObjectStore objectStore;
    Duration persistPeriod = Duration.millis(100);
    HighAvailabilityMode haMode;
    boolean forLive;
    boolean enableOsgi = false;
    boolean emptyCatalog;
    private boolean enablePersistenceBackups = true;

    ManagementContextBuilder(File mementoDir, ClassLoader classLoader) {
      this(classLoader, new FileBasedObjectStore(mementoDir));
    }

    ManagementContextBuilder(ClassLoader classLoader, File mementoDir) {
      this(classLoader, new FileBasedObjectStore(mementoDir));
    }

    ManagementContextBuilder(ClassLoader classLoader, PersistenceObjectStore objStore) {
      this.classLoader = checkNotNull(classLoader, "classLoader");
      this.objectStore = checkNotNull(objStore, "objStore");
    }

    public ManagementContextBuilder persistPeriodMillis(long persistPeriodMillis) {
      checkArgument(
          persistPeriodMillis > 0,
          "persistPeriodMillis must be greater than 0; was " + persistPeriodMillis);
      return persistPeriod(Duration.millis(persistPeriodMillis));
    }

    public ManagementContextBuilder persistPeriod(Duration persistPeriod) {
      checkNotNull(persistPeriod);
      this.persistPeriod = persistPeriod;
      return this;
    }

    public ManagementContextBuilder properties(BrooklynProperties properties) {
      this.properties = checkNotNull(properties, "properties");
      return this;
    }

    public ManagementContextBuilder forLive(boolean val) {
      this.forLive = val;
      return this;
    }

    public ManagementContextBuilder enablePersistenceBackups(boolean val) {
      this.enablePersistenceBackups = val;
      return this;
    }

    public ManagementContextBuilder enableOsgi(boolean val) {
      this.enableOsgi = val;
      return this;
    }

    public ManagementContextBuilder emptyCatalog() {
      this.emptyCatalog = true;
      return this;
    }

    public ManagementContextBuilder emptyCatalog(boolean val) {
      this.emptyCatalog = val;
      return this;
    }

    public ManagementContextBuilder haMode(HighAvailabilityMode val) {
      this.haMode = val;
      return this;
    }

    public LocalManagementContext buildUnstarted() {
      LocalManagementContext unstarted;
      BrooklynProperties properties =
          this.properties != null ? this.properties : BrooklynProperties.Factory.newDefault();
      if (this.emptyCatalog) {
        properties.putIfAbsent(
            BrooklynServerConfig.BROOKLYN_CATALOG_URL, ManagementContextInternal.EMPTY_CATALOG_URL);
      }
      if (!enablePersistenceBackups) {
        properties.putIfAbsent(
            BrooklynServerConfig.PERSISTENCE_BACKUPS_REQUIRED_ON_DEMOTION, false);
        properties.putIfAbsent(
            BrooklynServerConfig.PERSISTENCE_BACKUPS_REQUIRED_ON_PROMOTION, false);
        properties.putIfAbsent(BrooklynServerConfig.PERSISTENCE_BACKUPS_REQUIRED, false);
      }
      if (forLive) {
        unstarted = new LocalManagementContext(properties);
      } else {
        unstarted =
            LocalManagementContextForTests.builder(true)
                .useProperties(properties)
                .disableOsgi(!enableOsgi)
                .build();
      }

      objectStore.injectManagementContext(unstarted);
      objectStore.prepareForSharedUse(
          PersistMode.AUTO, (haMode == null ? HighAvailabilityMode.DISABLED : haMode));
      BrooklynMementoPersisterToObjectStore newPersister =
          new BrooklynMementoPersisterToObjectStore(
              objectStore, unstarted.getBrooklynProperties(), classLoader);
      ((RebindManagerImpl) unstarted.getRebindManager()).setPeriodicPersistPeriod(persistPeriod);
      unstarted
          .getRebindManager()
          .setPersister(newPersister, PersistenceExceptionHandlerImpl.builder().build());
      // set the HA persister, in case any children want to use HA
      unstarted
          .getHighAvailabilityManager()
          .setPersister(
              new ManagementPlaneSyncRecordPersisterToObjectStore(
                  unstarted, objectStore, classLoader));
      return unstarted;
    }

    public LocalManagementContext buildStarted() {
      LocalManagementContext unstarted = buildUnstarted();
      unstarted.getHighAvailabilityManager().disabled();
      unstarted.getRebindManager().startPersistence();
      return unstarted;
    }
  }

  /** Convenience for common call; delegates to {@link #rebind(RebindOptions)} */
  public static Application rebind(File mementoDir, ClassLoader classLoader) throws Exception {
    return rebind(RebindOptions.create().mementoDir(mementoDir).classLoader(classLoader));
  }

  /** @deprecated since 0.7.0; use {@link #rebind(RebindOptions)} */
  @Deprecated
  public static Application rebind(
      File mementoDir, ClassLoader classLoader, RebindExceptionHandler exceptionHandler)
      throws Exception {
    return rebind(
        RebindOptions.create()
            .mementoDir(mementoDir)
            .classLoader(classLoader)
            .exceptionHandler(exceptionHandler));
  }

  /** @deprecated since 0.7.0; use {@link #rebind(RebindOptions)} */
  @Deprecated
  public static Application rebind(ManagementContext newManagementContext, ClassLoader classLoader)
      throws Exception {
    return rebind(
        RebindOptions.create().newManagementContext(newManagementContext).classLoader(classLoader));
  }

  /** @deprecated since 0.7.0; use {@link #rebind(RebindOptions)} */
  @Deprecated
  public static Application rebind(
      ManagementContext newManagementContext,
      ClassLoader classLoader,
      RebindExceptionHandler exceptionHandler)
      throws Exception {
    return rebind(
        RebindOptions.create()
            .newManagementContext(newManagementContext)
            .classLoader(classLoader)
            .exceptionHandler(exceptionHandler));
  }

  /** @deprecated since 0.7.0; use {@link #rebind(RebindOptions)} */
  @Deprecated
  public static Application rebind(
      ManagementContext newManagementContext, File mementoDir, ClassLoader classLoader)
      throws Exception {
    return rebind(
        RebindOptions.create()
            .newManagementContext(newManagementContext)
            .mementoDir(mementoDir)
            .classLoader(classLoader));
  }

  /** @deprecated since 0.7.0; use {@link #rebind(RebindOptions)} */
  @Deprecated
  public static Application rebind(
      ManagementContext newManagementContext,
      File mementoDir,
      ClassLoader classLoader,
      RebindExceptionHandler exceptionHandler)
      throws Exception {
    return rebind(
        RebindOptions.create()
            .newManagementContext(newManagementContext)
            .mementoDir(mementoDir)
            .classLoader(classLoader)
            .exceptionHandler(exceptionHandler));
  }

  /** @deprecated since 0.7.0; use {@link #rebind(RebindOptions)} */
  @Deprecated
  public static Application rebind(
      ManagementContext newManagementContext,
      File mementoDir,
      ClassLoader classLoader,
      RebindExceptionHandler exceptionHandler,
      PersistenceObjectStore objectStore)
      throws Exception {
    return rebind(
        RebindOptions.create()
            .newManagementContext(newManagementContext)
            .mementoDir(mementoDir)
            .classLoader(classLoader)
            .exceptionHandler(exceptionHandler)
            .objectStore(objectStore));
  }

  public static Application rebind(RebindOptions options) throws Exception {
    Collection<Application> newApps = rebindAll(options);
    if (newApps.isEmpty())
      throw new IllegalStateException(
          "Application could not be rebinded; serialization probably failed");
    return Iterables.getFirst(newApps, null);
  }

  /** @deprecated since 0.7.0; use {@link #rebindAll(RebindOptions)} */
  @Deprecated
  public static Collection<Application> rebindAll(File mementoDir, ClassLoader classLoader)
      throws Exception {
    return rebindAll(RebindOptions.create().mementoDir(mementoDir).classLoader(classLoader));
  }

  /** @deprecated since 0.7.0; use {@link #rebind(RebindOptions)} */
  @Deprecated
  public static Collection<Application> rebindAll(
      File mementoDir, ClassLoader classLoader, RebindExceptionHandler exceptionHandler)
      throws Exception {
    return rebindAll(
        RebindOptions.create()
            .mementoDir(mementoDir)
            .classLoader(classLoader)
            .exceptionHandler(exceptionHandler));
  }

  /** @deprecated since 0.7.0; use {@link #rebind(RebindOptions)} */
  @Deprecated
  public static Collection<Application> rebindAll(
      LocalManagementContext newManagementContext,
      ClassLoader classLoader,
      RebindExceptionHandler exceptionHandler)
      throws Exception {
    return rebindAll(
        RebindOptions.create()
            .newManagementContext(newManagementContext)
            .classLoader(classLoader)
            .exceptionHandler(exceptionHandler));
  }

  /** @deprecated since 0.7.0; use {@link #rebind(RebindOptions)} */
  @Deprecated
  public static Collection<Application> rebindAll(
      ManagementContext newManagementContext, File mementoDir, ClassLoader classLoader)
      throws Exception {
    return rebindAll(
        RebindOptions.create()
            .newManagementContext(newManagementContext)
            .mementoDir(mementoDir)
            .classLoader(classLoader));
  }

  /** @deprecated since 0.7.0; use {@link #rebind(RebindOptions)} */
  @Deprecated
  public static Collection<Application> rebindAll(
      ManagementContext newManagementContext,
      File mementoDir,
      ClassLoader classLoader,
      RebindExceptionHandler exceptionHandler,
      PersistenceObjectStore objectStore)
      throws Exception {
    return rebindAll(
        RebindOptions.create()
            .newManagementContext(newManagementContext)
            .mementoDir(mementoDir)
            .classLoader(classLoader)
            .exceptionHandler(exceptionHandler)
            .objectStore(objectStore));
  }

  public static Collection<Application> rebindAll(RebindOptions options) throws Exception {
    File mementoDir = options.mementoDir;
    File mementoDirBackup = options.mementoDirBackup;
    ClassLoader classLoader = checkNotNull(options.classLoader, "classLoader");
    ManagementContextInternal origManagementContext =
        (ManagementContextInternal) options.origManagementContext;
    ManagementContextInternal newManagementContext =
        (ManagementContextInternal) options.newManagementContext;
    PersistenceObjectStore objectStore = options.objectStore;
    HighAvailabilityMode haMode =
        (options.haMode == null ? HighAvailabilityMode.DISABLED : options.haMode);
    RebindExceptionHandler exceptionHandler = options.exceptionHandler;
    boolean hasPersister =
        newManagementContext != null
            && newManagementContext.getRebindManager().getPersister() != null;
    boolean checkSerializable = options.checkSerializable;
    boolean terminateOrigManagementContext = options.terminateOrigManagementContext;
    Function<BrooklynMementoPersister, Void> stateTransformer = options.stateTransformer;

    LOG.info("Rebinding app, using mementoDir " + mementoDir + "; object store " + objectStore);

    if (newManagementContext == null) {
      // TODO Could use empty properties, to save reading brooklyn.properties file.
      // Would that affect any tests?
      newManagementContext =
          new LocalManagementContextForTests(BrooklynProperties.Factory.newDefault());
    }
    if (!hasPersister) {
      if (objectStore == null) {
        objectStore =
            new FileBasedObjectStore(
                checkNotNull(mementoDir, "mementoDir and objectStore must not both be null"));
      }
      objectStore.injectManagementContext(newManagementContext);
      objectStore.prepareForSharedUse(PersistMode.AUTO, haMode);

      BrooklynMementoPersisterToObjectStore newPersister =
          new BrooklynMementoPersisterToObjectStore(
              objectStore, newManagementContext.getBrooklynProperties(), classLoader);
      newManagementContext
          .getRebindManager()
          .setPersister(newPersister, PersistenceExceptionHandlerImpl.builder().build());
    } else {
      if (objectStore != null)
        throw new IllegalStateException(
            "Must not supply ManagementContext with persister and an object store");
    }

    if (checkSerializable) {
      checkNotNull(
          origManagementContext, "must supply origManagementContext with checkSerializable");
      RebindTestUtils.checkCurrentMementoSerializable(origManagementContext);
    }

    if (terminateOrigManagementContext) {
      checkNotNull(
          origManagementContext,
          "must supply origManagementContext with terminateOrigManagementContext");
      origManagementContext.terminate();
    }

    if (mementoDirBackup != null) {
      FileUtil.copyDir(mementoDir, mementoDirBackup);
      FileUtil.setFilePermissionsTo700(mementoDirBackup);
    }

    if (stateTransformer != null) {
      BrooklynMementoPersister persister = newManagementContext.getRebindManager().getPersister();
      stateTransformer.apply(persister);
    }

    List<Application> newApps =
        newManagementContext
            .getRebindManager()
            .rebind(
                classLoader,
                exceptionHandler,
                (haMode == HighAvailabilityMode.DISABLED)
                    ? ManagementNodeState.MASTER
                    : ManagementNodeState.of(haMode).get());
    newManagementContext.getRebindManager().startPersistence();
    return newApps;
  }

  public static void waitForPersisted(Application origApp)
      throws InterruptedException, TimeoutException {
    waitForPersisted(origApp.getManagementContext());
  }

  public static void waitForPersisted(ManagementContext managementContext)
      throws InterruptedException, TimeoutException {
    managementContext.getRebindManager().waitForPendingComplete(TIMEOUT, true);
  }

  public static void checkCurrentMementoSerializable(Application app) throws Exception {
    checkCurrentMementoSerializable(app.getManagementContext());
  }

  public static void checkCurrentMementoSerializable(ManagementContext mgmt) throws Exception {
    BrooklynMemento memento = MementosGenerators.newBrooklynMemento(mgmt);
    serializeAndDeserialize(memento);
  }

  /**
   * Dumps out the persisted mementos that are at the given directory.
   *
   * <p>Binds to the persisted state (as a "hot standby") to load the raw data (as strings), and to
   * write out the entity, location, policy, enricher, feed and catalog-item data.
   *
   * @param dir The directory containing the persisted state
   */
  public static void dumpMementoDir(File dir) {
    LocalManagementContextForTests mgmt =
        new LocalManagementContextForTests(BrooklynProperties.Factory.newEmpty());
    FileBasedObjectStore store = null;
    BrooklynMementoPersisterToObjectStore persister = null;
    try {
      store = new FileBasedObjectStore(dir);
      store.injectManagementContext(mgmt);
      store.prepareForSharedUse(PersistMode.AUTO, HighAvailabilityMode.HOT_STANDBY);
      persister =
          new BrooklynMementoPersisterToObjectStore(
              store, BrooklynProperties.Factory.newEmpty(), RebindTestUtils.class.getClassLoader());
      BrooklynMementoRawData data =
          persister.loadMementoRawData(RebindExceptionHandlerImpl.builder().build());
      List<BrooklynObjectType> types =
          ImmutableList.of(
              BrooklynObjectType.ENTITY,
              BrooklynObjectType.LOCATION,
              BrooklynObjectType.POLICY,
              BrooklynObjectType.ENRICHER,
              BrooklynObjectType.FEED,
              BrooklynObjectType.CATALOG_ITEM);
      for (BrooklynObjectType type : types) {
        LOG.info(type + " (" + data.getObjectsOfType(type).keySet() + "):");
        for (Map.Entry<String, String> entry : data.getObjectsOfType(type).entrySet()) {
          LOG.info("\t" + type + " " + entry.getKey() + ": " + entry.getValue());
        }
      }
    } finally {
      if (persister != null) persister.stop(false);
      if (store != null) store.close();
      mgmt.terminate();
    }
  }
}