protected void configureRenderingMetadata(ApplicationSpec spec, ApplicationBuilder appBuilder) {
   appBuilder.configure(getRenderingConfigurationFor(spec.getType()));
 }
  @SuppressWarnings("unchecked")
  public Application create(ApplicationSpec spec) {
    log.debug("REST creating application instance for {}", spec);

    if (!Entitlements.isEntitled(
        mgmt.getEntitlementManager(), Entitlements.DEPLOY_APPLICATION, spec)) {
      throw WebResourceUtils.unauthorized(
          "User '%s' is not authorized to deploy application %s",
          Entitlements.getEntitlementContext().user(), spec);
    }

    final String type = spec.getType();
    final String name = spec.getName();
    final Map<String, String> configO = spec.getConfig();
    final Set<EntitySpec> entities =
        (spec.getEntities() == null) ? ImmutableSet.<EntitySpec>of() : spec.getEntities();

    final Application instance;

    // Load the class; first try to use the appropriate catalog item; but then allow anything that
    // is on the classpath
    final Class<? extends Entity> clazz;
    if (Strings.isEmpty(type)) {
      clazz = BasicApplication.class;
    } else {
      Class<? extends Entity> tempclazz;
      try {
        tempclazz = getCatalog().loadClassByType(type, Entity.class);
      } catch (NoSuchElementException e) {
        try {
          tempclazz = (Class<? extends Entity>) getCatalog().getRootClassLoader().loadClass(type);
          log.info(
              "Catalog does not contain item for type {}; loaded class directly instead", type);
        } catch (ClassNotFoundException e2) {
          log.warn(
              "No catalog item for type {}, and could not load class directly; rethrowing", type);
          throw e;
        }
      }
      clazz = tempclazz;
    }
    if (Entitlements.isEntitled(mgmt.getEntitlementManager(), Entitlements.INVOKE_EFFECTOR, null)) {

      try {
        if (ApplicationBuilder.class.isAssignableFrom(clazz)) {
          Constructor<?> constructor = clazz.getConstructor();
          ApplicationBuilder appBuilder = (ApplicationBuilder) constructor.newInstance();
          if (!Strings.isEmpty(name)) appBuilder.appDisplayName(name);
          if (entities.size() > 0)
            log.warn(
                "Cannot supply additional entities when using an ApplicationBuilder; ignoring in spec {}",
                spec);

          log.info("REST placing '{}' under management", spec.getName());
          appBuilder.configure(convertFlagsToKeys(appBuilder.getType(), configO));
          configureRenderingMetadata(spec, appBuilder);
          instance = appBuilder.manage(mgmt);

        } else if (Application.class.isAssignableFrom(clazz)) {
          brooklyn.entity.proxying.EntitySpec<?> coreSpec = toCoreEntitySpec(clazz, name, configO);
          configureRenderingMetadata(spec, coreSpec);
          instance = (Application) mgmt.getEntityManager().createEntity(coreSpec);
          for (EntitySpec entitySpec : entities) {
            log.info("REST creating instance for entity {}", entitySpec.getType());
            instance.addChild(mgmt.getEntityManager().createEntity(toCoreEntitySpec(entitySpec)));
          }

          log.info(
              "REST placing '{}' under management", spec.getName() != null ? spec.getName() : spec);
          Entities.startManagement(instance, mgmt);

        } else if (Entity.class.isAssignableFrom(clazz)) {
          if (entities.size() > 0)
            log.warn(
                "Cannot supply additional entities when using a non-application entity; ignoring in spec {}",
                spec);

          brooklyn.entity.proxying.EntitySpec<?> coreSpec =
              toCoreEntitySpec(BasicApplication.class, name, configO);
          configureRenderingMetadata(spec, coreSpec);

          instance = (Application) mgmt.getEntityManager().createEntity(coreSpec);

          final Class<? extends Entity> eclazz =
              getCatalog().loadClassByType(spec.getType(), Entity.class);
          Entity soleChild =
              mgmt.getEntityManager().createEntity(toCoreEntitySpec(eclazz, name, configO));
          instance.addChild(soleChild);
          instance.addEnricher(Enrichers.builder().propagatingAll().from(soleChild).build());

          log.info("REST placing '{}' under management", spec.getName());
          Entities.startManagement(instance, mgmt);

        } else {
          throw new IllegalArgumentException(
              "Class " + clazz + " must extend one of ApplicationBuilder, Application or Entity");
        }

        return instance;

      } catch (Exception e) {
        log.error("REST failed to create application: " + e, e);
        throw Exceptions.propagate(e);
      }
    }
    throw WebResourceUtils.unauthorized(
        "User '%s' is not authorized to create application from applicationSpec %s",
        Entitlements.getEntitlementContext().user(), spec);
  }