http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/ApplicationTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/ApplicationTransformer.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/ApplicationTransformer.java new file mode 100644 index 0000000..2ba84d9 --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/ApplicationTransformer.java @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.rest.transform; + +import static brooklyn.rest.domain.Status.ACCEPTED; +import static brooklyn.rest.domain.Status.RUNNING; +import static brooklyn.rest.domain.Status.STARTING; +import static brooklyn.rest.domain.Status.STOPPED; +import static brooklyn.rest.domain.Status.STOPPING; +import static brooklyn.rest.domain.Status.UNKNOWN; +import static brooklyn.rest.domain.Status.DESTROYED; +import static brooklyn.rest.domain.Status.ERROR; + +import java.net.URI; +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +import javax.annotation.Nullable; + +import brooklyn.entity.Application; +import brooklyn.entity.basic.Attributes; +import brooklyn.entity.basic.Lifecycle; +import brooklyn.entity.trait.Startable; +import brooklyn.location.Location; +import brooklyn.rest.domain.ApplicationSpec; +import brooklyn.rest.domain.ApplicationSummary; +import brooklyn.rest.domain.Status; + +import com.google.common.base.Function; +import com.google.common.collect.Collections2; +import com.google.common.collect.ImmutableMap; + +public class ApplicationTransformer { + + public static final Function<? super Application, ApplicationSummary> FROM_APPLICATION = new Function<Application, ApplicationSummary>() { + @Override + public ApplicationSummary apply(Application input) { + return summaryFromApplication(input); + } + }; + + public static Status statusFromApplication(Application application) { + if (application == null) return UNKNOWN; + Lifecycle state = application.getAttribute(Attributes.SERVICE_STATE_ACTUAL); + if (state != null) return statusFromLifecycle(state); + Boolean up = application.getAttribute(Startable.SERVICE_UP); + if (up != null && up.booleanValue()) return RUNNING; + return UNKNOWN; + } + + + public static Status statusFromLifecycle(Lifecycle state) { + if (state == null) return UNKNOWN; + switch (state) { + case CREATED: + return ACCEPTED; + case STARTING: + return STARTING; + case RUNNING: + return RUNNING; + case STOPPING: + return STOPPING; + case STOPPED: + return STOPPED; + case DESTROYED: + return DESTROYED; + case ON_FIRE: + return ERROR; + default: + return UNKNOWN; + } + } + + public static ApplicationSpec specFromApplication(Application application) { + Collection<String> locations = Collections2.transform(application.getLocations(), new Function<Location, String>() { + @Override + @Nullable + public String apply(@Nullable Location input) { + return input.getId(); + } + }); + // okay to have entities and config as null, as this comes from a real instance + return new ApplicationSpec(application.getDisplayName(), application.getEntityType().getName(), + null, locations, null); + } + + public static ApplicationSummary summaryFromApplication(Application application) { + Map<String, URI> links; + if (application.getId() == null) { + links = Collections.emptyMap(); + } else { + links = ImmutableMap.of( + "self", URI.create("/v1/applications/" + application.getId()), + "entities", URI.create("/v1/applications/" + application.getId() + "/entities")); + } + + return new ApplicationSummary(application.getId(), specFromApplication(application), statusFromApplication(application), links); + } +}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/BrooklynFeatureTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/BrooklynFeatureTransformer.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/BrooklynFeatureTransformer.java new file mode 100644 index 0000000..37d1643 --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/BrooklynFeatureTransformer.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.brooklyn.rest.transform; + +import com.google.common.base.Function; + +import brooklyn.BrooklynVersion.BrooklynFeature; +import brooklyn.rest.domain.BrooklynFeatureSummary; + +public class BrooklynFeatureTransformer { + + public static final Function<BrooklynFeature, BrooklynFeatureSummary> FROM_FEATURE = new Function<BrooklynFeature, BrooklynFeatureSummary>() { + @Override + public BrooklynFeatureSummary apply(BrooklynFeature feature) { + return featureSummary(feature); + } + }; + + public static BrooklynFeatureSummary featureSummary(BrooklynFeature feature) { + return new BrooklynFeatureSummary( + feature.getName(), + feature.getSymbolicName(), + feature.getVersion(), + feature.getLastModified(), + feature.getAdditionalData()); + } + +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/CatalogTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/CatalogTransformer.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/CatalogTransformer.java new file mode 100644 index 0000000..8620142 --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/CatalogTransformer.java @@ -0,0 +1,163 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.rest.transform; + +import java.net.URI; +import java.util.Map; +import java.util.Set; + +import org.slf4j.LoggerFactory; + +import brooklyn.basic.BrooklynTypes; +import org.apache.brooklyn.catalog.CatalogItem; +import org.apache.brooklyn.catalog.CatalogItem.CatalogItemType; +import brooklyn.config.ConfigKey; +import brooklyn.entity.Effector; +import brooklyn.entity.Entity; +import brooklyn.entity.EntityType; +import brooklyn.entity.basic.EntityDynamicType; +import brooklyn.entity.proxying.EntitySpec; +import brooklyn.event.Sensor; +import brooklyn.location.Location; +import brooklyn.location.LocationSpec; +import brooklyn.policy.Policy; +import brooklyn.policy.PolicySpec; +import brooklyn.rest.domain.CatalogEntitySummary; +import brooklyn.rest.domain.CatalogItemSummary; +import brooklyn.rest.domain.CatalogLocationSummary; +import brooklyn.rest.domain.CatalogPolicySummary; +import brooklyn.rest.domain.EffectorSummary; +import brooklyn.rest.domain.EntityConfigSummary; +import brooklyn.rest.domain.LocationConfigSummary; +import brooklyn.rest.domain.PolicyConfigSummary; +import brooklyn.rest.domain.SensorSummary; +import brooklyn.rest.domain.SummaryComparators; +import org.apache.brooklyn.rest.util.BrooklynRestResourceUtils; +import brooklyn.util.collections.MutableMap; +import brooklyn.util.exceptions.Exceptions; + +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Sets; + +public class CatalogTransformer { + + private static final org.slf4j.Logger log = LoggerFactory.getLogger(CatalogTransformer.class); + + public static CatalogEntitySummary catalogEntitySummary(BrooklynRestResourceUtils b, CatalogItem<? extends Entity,EntitySpec<?>> item) { + Set<EntityConfigSummary> config = Sets.newTreeSet(SummaryComparators.nameComparator()); + Set<SensorSummary> sensors = Sets.newTreeSet(SummaryComparators.nameComparator()); + Set<EffectorSummary> effectors = Sets.newTreeSet(SummaryComparators.nameComparator()); + + try { + EntitySpec<?> spec = b.getCatalog().createSpec(item); + EntityDynamicType typeMap = BrooklynTypes.getDefinedEntityType(spec.getType()); + EntityType type = typeMap.getSnapshot(); + + for (ConfigKey<?> x: type.getConfigKeys()) + config.add(EntityTransformer.entityConfigSummary(x, typeMap.getConfigKeyField(x.getName()))); + for (Sensor<?> x: type.getSensors()) + sensors.add(SensorTransformer.sensorSummaryForCatalog(x)); + for (Effector<?> x: type.getEffectors()) + effectors.add(EffectorTransformer.effectorSummaryForCatalog(x)); + + } catch (Exception e) { + Exceptions.propagateIfFatal(e); + + // templates with multiple entities can't have spec created in the manner above; just ignore + if (item.getCatalogItemType()==CatalogItemType.ENTITY) { + log.warn("Unable to create spec for "+item+": "+e, e); + } + if (log.isTraceEnabled()) { + log.trace("Unable to create spec for "+item+": "+e, e); + } + } + + return new CatalogEntitySummary(item.getSymbolicName(), item.getVersion(), item.getDisplayName(), + item.getJavaType(), item.getPlanYaml(), + item.getDescription(), tidyIconLink(b, item, item.getIconUrl()), + config, sensors, effectors, + item.isDeprecated(), makeLinks(item)); + } + + @SuppressWarnings("unchecked") + public static CatalogItemSummary catalogItemSummary(BrooklynRestResourceUtils b, CatalogItem<?,?> item) { + try { + switch (item.getCatalogItemType()) { + case TEMPLATE: + case ENTITY: + return catalogEntitySummary(b, (CatalogItem<? extends Entity, EntitySpec<?>>) item); + case POLICY: + return catalogPolicySummary(b, (CatalogItem<? extends Policy, PolicySpec<?>>) item); + case LOCATION: + return catalogLocationSummary(b, (CatalogItem<? extends Location, LocationSpec<?>>) item); + default: + log.warn("Unexpected catalog item type when getting self link (supplying generic item): "+item.getCatalogItemType()+" "+item); + } + } catch (Exception e) { + Exceptions.propagateIfFatal(e); + log.warn("Invalid item in catalog when converting REST summaries (supplying generic item), at "+item+": "+e, e); + } + return new CatalogItemSummary(item.getSymbolicName(), item.getVersion(), item.getDisplayName(), + item.getJavaType(), item.getPlanYaml(), + item.getDescription(), tidyIconLink(b, item, item.getIconUrl()), item.isDeprecated(), makeLinks(item)); + } + + public static CatalogPolicySummary catalogPolicySummary(BrooklynRestResourceUtils b, CatalogItem<? extends Policy,PolicySpec<?>> item) { + Set<PolicyConfigSummary> config = ImmutableSet.of(); + return new CatalogPolicySummary(item.getSymbolicName(), item.getVersion(), item.getDisplayName(), + item.getJavaType(), item.getPlanYaml(), + item.getDescription(), tidyIconLink(b, item, item.getIconUrl()), config, + item.isDeprecated(), makeLinks(item)); + } + + public static CatalogLocationSummary catalogLocationSummary(BrooklynRestResourceUtils b, CatalogItem<? extends Location,LocationSpec<?>> item) { + Set<LocationConfigSummary> config = ImmutableSet.of(); + return new CatalogLocationSummary(item.getSymbolicName(), item.getVersion(), item.getDisplayName(), + item.getJavaType(), item.getPlanYaml(), + item.getDescription(), tidyIconLink(b, item, item.getIconUrl()), config, + item.isDeprecated(), makeLinks(item)); + } + + protected static Map<String, URI> makeLinks(CatalogItem<?,?> item) { + return MutableMap.<String, URI>of().addIfNotNull("self", URI.create(getSelfLink(item))); + } + + protected static String getSelfLink(CatalogItem<?,?> item) { + String itemId = item.getId(); + switch (item.getCatalogItemType()) { + case TEMPLATE: + return "/v1/applications/" + itemId + "/" + item.getVersion(); + case ENTITY: + return "/v1/entities/" + itemId + "/" + item.getVersion(); + case POLICY: + return "/v1/policies/" + itemId + "/" + item.getVersion(); + case LOCATION: + return "/v1/locations/" + itemId + "/" + item.getVersion(); + default: + log.warn("Unexpected catalog item type when getting self link (not supplying self link): "+item.getCatalogItemType()+" "+item); + return null; + } + } + private static String tidyIconLink(BrooklynRestResourceUtils b, CatalogItem<?,?> item, String iconUrl) { + if (b.isUrlServerSideAndSafe(iconUrl)) + return "/v1/catalog/icon/"+item.getSymbolicName() + "/" + item.getVersion(); + return iconUrl; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/EffectorTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/EffectorTransformer.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/EffectorTransformer.java new file mode 100644 index 0000000..3489942 --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/EffectorTransformer.java @@ -0,0 +1,86 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.rest.transform; + +import java.net.URI; +import java.util.Set; + +import javax.annotation.Nullable; + +import brooklyn.entity.Effector; +import brooklyn.entity.Entity; +import brooklyn.entity.ParameterType; +import brooklyn.entity.basic.EntityLocal; +import brooklyn.rest.domain.EffectorSummary; +import brooklyn.rest.domain.EffectorSummary.ParameterSummary; +import org.apache.brooklyn.rest.util.WebResourceUtils; +import brooklyn.util.exceptions.Exceptions; +import brooklyn.util.guava.Maybe; +import brooklyn.util.task.Tasks; +import brooklyn.util.task.ValueResolver; + +import com.google.common.base.Function; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; + +public class EffectorTransformer { + + public static EffectorSummary effectorSummary(final EntityLocal entity, Effector<?> effector) { + String applicationUri = "/v1/applications/" + entity.getApplicationId(); + String entityUri = applicationUri + "/entities/" + entity.getId(); + return new EffectorSummary(effector.getName(), effector.getReturnTypeName(), + ImmutableSet.copyOf(Iterables.transform(effector.getParameters(), + new Function<ParameterType<?>, EffectorSummary.ParameterSummary<?>>() { + @Override + public EffectorSummary.ParameterSummary<?> apply(@Nullable ParameterType<?> parameterType) { + return parameterSummary(entity, parameterType); + } + })), effector.getDescription(), ImmutableMap.of( + "self", URI.create(entityUri + "/effectors/" + effector.getName()), + "entity", URI.create(entityUri), + "application", URI.create(applicationUri) + )); + } + + public static EffectorSummary effectorSummaryForCatalog(Effector<?> effector) { + Set<EffectorSummary.ParameterSummary<?>> parameters = ImmutableSet.copyOf(Iterables.transform(effector.getParameters(), + new Function<ParameterType<?>, EffectorSummary.ParameterSummary<?>>() { + @Override + public EffectorSummary.ParameterSummary<?> apply(ParameterType<?> parameterType) { + return parameterSummary(null, parameterType); + } + })); + return new EffectorSummary(effector.getName(), + effector.getReturnTypeName(), parameters, effector.getDescription(), null); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + protected static EffectorSummary.ParameterSummary<?> parameterSummary(Entity entity, ParameterType<?> parameterType) { + try { + Maybe<?> defaultValue = Tasks.resolving(parameterType.getDefaultValue()).as(parameterType.getParameterClass()) + .context(entity).timeout(ValueResolver.REAL_QUICK_WAIT).getMaybe(); + return new ParameterSummary(parameterType.getName(), parameterType.getParameterClassName(), + parameterType.getDescription(), + WebResourceUtils.getValueForDisplay(defaultValue.orNull(), true, false)); + } catch (Exception e) { + throw Exceptions.propagate(e); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/EntityTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/EntityTransformer.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/EntityTransformer.java new file mode 100644 index 0000000..3ba7cd8 --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/EntityTransformer.java @@ -0,0 +1,155 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.rest.transform; + +import static com.google.common.collect.Iterables.transform; + +import java.lang.reflect.Field; +import java.net.URI; +import java.util.List; +import java.util.Map; + +import org.apache.brooklyn.catalog.CatalogConfig; +import brooklyn.config.ConfigKey; +import brooklyn.config.render.RendererHints; +import brooklyn.entity.Application; +import brooklyn.entity.Entity; +import brooklyn.entity.basic.EntityLocal; +import brooklyn.rest.domain.EntityConfigSummary; +import brooklyn.rest.domain.EntitySummary; +import org.apache.brooklyn.rest.util.WebResourceUtils; +import brooklyn.util.collections.MutableMap; +import brooklyn.util.net.URLParamEncoder; + +import com.google.common.base.Function; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; + +/** + * @author Adam Lowe + */ +public class EntityTransformer { + + public static final Function<? super Entity, EntitySummary> FROM_ENTITY = new Function<Entity, EntitySummary>() { + @Override + public EntitySummary apply(Entity entity) { + return EntityTransformer.entitySummary(entity); + } + }; + + public static EntitySummary entitySummary(Entity entity) { + String applicationUri = "/v1/applications/" + entity.getApplicationId(); + String entityUri = applicationUri + "/entities/" + entity.getId(); + ImmutableMap.Builder<String, URI> lb = ImmutableMap.<String, URI>builder() + .put("self", URI.create(entityUri)); + if (entity.getParent()!=null) + lb.put("parent", URI.create(applicationUri+"/entities/"+entity.getParent().getId())); + String type = entity.getEntityType().getName(); + lb.put("application", URI.create(applicationUri)) + .put("children", URI.create(entityUri + "/children")) + .put("config", URI.create(entityUri + "/config")) + .put("sensors", URI.create(entityUri + "/sensors")) + .put("effectors", URI.create(entityUri + "/effectors")) + .put("policies", URI.create(entityUri + "/policies")) + .put("activities", URI.create(entityUri + "/activities")) + .put("locations", URI.create(entityUri + "/locations")) + .put("tags", URI.create(entityUri + "/tags")) + .put("expunge", URI.create(entityUri + "/expunge")) + .put("rename", URI.create(entityUri + "/name")) + .put("spec", URI.create(entityUri + "/spec")) + ; + + if (entity.getCatalogItemId() != null) { + lb.put("catalog", URI.create("/v1/catalog/entities/" + WebResourceUtils.getPathFromVersionedId(entity.getCatalogItemId()))); + } + + if (entity.getIconUrl()!=null) + lb.put("iconUrl", URI.create(entityUri + "/icon")); + + return new EntitySummary(entity.getId(), entity.getDisplayName(), type, entity.getCatalogItemId(), lb.build()); + } + + public static List<EntitySummary> entitySummaries(Iterable<? extends Entity> entities) { + return Lists.newArrayList(transform( + entities, + new Function<Entity, EntitySummary>() { + @Override + public EntitySummary apply(Entity entity) { + return EntityTransformer.entitySummary(entity); + } + })); + } + + protected static EntityConfigSummary entityConfigSummary(ConfigKey<?> config, String label, Double priority, Map<String, URI> links) { + Map<String, URI> mapOfLinks = links==null ? null : ImmutableMap.copyOf(links); + return new EntityConfigSummary(config, label, priority, mapOfLinks); + } + /** generates a representation for a given config key, + * with label inferred from annoation in the entity class, + * and links pointing to the entity and the applicaiton */ + public static EntityConfigSummary entityConfigSummary(EntityLocal entity, ConfigKey<?> config) { + /* + * following code nearly there to get the @CatalogConfig annotation + * in the class and use that to populate a label + */ + +// EntityDynamicType typeMap = +// ((AbstractEntity)entity).getMutableEntityType(); +// // above line works if we can cast; line below won't work, but there should some way +// // to get back the handle to the spec from an entity local, which then *would* work +// EntityTypes.getDefinedEntityType(entity.getClass()); + +// String label = typeMap.getConfigKeyField(config.getName()); + String label = null; + Double priority = null; + + String applicationUri = "/v1/applications/" + entity.getApplicationId(); + String entityUri = applicationUri + "/entities/" + entity.getId(); + String selfUri = entityUri + "/config/" + URLParamEncoder.encode(config.getName()); + + MutableMap.Builder<String, URI> lb = MutableMap.<String, URI>builder() + .put("self", URI.create(selfUri)) + .put("application", URI.create(applicationUri)) + .put("entity", URI.create(entityUri)) + .put("action:json", URI.create(selfUri)); + + Iterable<RendererHints.NamedAction> hints = Iterables.filter(RendererHints.getHintsFor(config), RendererHints.NamedAction.class); + for (RendererHints.NamedAction na : hints) { + SensorTransformer.addNamedAction(lb, na, entity.getConfig(config), config, entity); + } + + return entityConfigSummary(config, label, priority, lb.build()); + } + + public static String applicationUri(Application entity) { + return "/v1/applications/" + entity.getApplicationId(); + } + + public static String entityUri(Entity entity) { + return applicationUri(entity.getApplication()) + "/entities/" + entity.getId(); + } + + public static EntityConfigSummary entityConfigSummary(ConfigKey<?> config, Field configKeyField) { + CatalogConfig catalogConfig = configKeyField!=null ? configKeyField.getAnnotation(CatalogConfig.class) : null; + String label = catalogConfig==null ? null : catalogConfig.label(); + Double priority = catalogConfig==null ? null : catalogConfig.priority(); + return entityConfigSummary(config, label, priority, null); + } +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/HighAvailabilityTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/HighAvailabilityTransformer.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/HighAvailabilityTransformer.java new file mode 100644 index 0000000..61d0f49 --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/HighAvailabilityTransformer.java @@ -0,0 +1,50 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.rest.transform; + +import java.net.URI; +import java.util.Map; + +import brooklyn.management.ha.ManagementPlaneSyncRecord; +import brooklyn.management.ha.ManagementNodeSyncRecord; +import brooklyn.rest.domain.HighAvailabilitySummary; +import brooklyn.rest.domain.HighAvailabilitySummary.HaNodeSummary; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Maps; + +public class HighAvailabilityTransformer { + + public static HighAvailabilitySummary highAvailabilitySummary(String ownNodeId, ManagementPlaneSyncRecord memento) { + Map<String, HaNodeSummary> nodes = Maps.newLinkedHashMap(); + for (Map.Entry<String, ManagementNodeSyncRecord> entry : memento.getManagementNodes().entrySet()) { + nodes.put(entry.getKey(), haNodeSummary(entry.getValue())); + } + + // TODO What links? + ImmutableMap.Builder<String, URI> lb = ImmutableMap.<String, URI>builder(); + + return new HighAvailabilitySummary(ownNodeId, memento.getMasterNodeId(), nodes, lb.build()); + } + + public static HaNodeSummary haNodeSummary(ManagementNodeSyncRecord memento) { + String status = memento.getStatus() == null ? null : memento.getStatus().toString(); + return new HaNodeSummary(memento.getNodeId(), memento.getUri(), status, memento.getLocalTimestamp(), memento.getRemoteTimestamp()); + } +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/LocationTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/LocationTransformer.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/LocationTransformer.java new file mode 100644 index 0000000..240845e --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/LocationTransformer.java @@ -0,0 +1,194 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.rest.transform; + +import java.net.URI; +import java.util.Map; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import brooklyn.entity.basic.Sanitizer; +import brooklyn.location.Location; +import brooklyn.location.LocationDefinition; +import brooklyn.location.basic.BasicLocationDefinition; +import brooklyn.location.basic.LocationConfigKeys; +import brooklyn.location.basic.LocationInternal; +import brooklyn.management.ManagementContext; +import brooklyn.rest.domain.LocationSummary; +import org.apache.brooklyn.rest.util.WebResourceUtils; +import brooklyn.util.collections.MutableMap; +import brooklyn.util.config.ConfigBag; +import brooklyn.util.guava.Maybe; +import brooklyn.util.text.Strings; + +import com.google.common.collect.ImmutableMap; + +public class LocationTransformer { + + @SuppressWarnings("unused") + private static final Logger log = LoggerFactory.getLogger(LocationTransformer.LocationDetailLevel.class); + + public static enum LocationDetailLevel { NONE, LOCAL_EXCLUDING_SECRET, FULL_EXCLUDING_SECRET, FULL_INCLUDING_SECRET } + + /** @deprecated since 0.7.0 use method taking management context and detail specifier */ + @Deprecated + public static LocationSummary newInstance(String id, brooklyn.rest.domain.LocationSpec locationSpec) { + return newInstance(null, id, locationSpec, LocationDetailLevel.LOCAL_EXCLUDING_SECRET); + } + @SuppressWarnings("deprecation") + public static LocationSummary newInstance(ManagementContext mgmt, String id, brooklyn.rest.domain.LocationSpec locationSpec, LocationDetailLevel level) { + // TODO: Remove null checks on mgmt when newInstance(String, LocationSpec) is deleted + Map<String, ?> config = locationSpec.getConfig(); + if (mgmt != null && (level==LocationDetailLevel.FULL_EXCLUDING_SECRET || level==LocationDetailLevel.FULL_INCLUDING_SECRET)) { + LocationDefinition ld = new BasicLocationDefinition(id, locationSpec.getName(), locationSpec.getSpec(), locationSpec.getConfig()); + Location ll = mgmt.getLocationRegistry().resolve(ld, false, null).orNull(); + if (ll!=null) config = ((LocationInternal)ll).config().getBag().getAllConfig(); + } else if (level==LocationDetailLevel.LOCAL_EXCLUDING_SECRET) { + // get displayName + if (!config.containsKey(LocationConfigKeys.DISPLAY_NAME.getName()) && mgmt!=null) { + LocationDefinition ld = new BasicLocationDefinition(id, locationSpec.getName(), locationSpec.getSpec(), locationSpec.getConfig()); + Location ll = mgmt.getLocationRegistry().resolve(ld, false, null).orNull(); + if (ll!=null) { + Map<String, Object> configExtra = ((LocationInternal)ll).config().getBag().getAllConfig(); + if (configExtra.containsKey(LocationConfigKeys.DISPLAY_NAME.getName())) { + ConfigBag configNew = ConfigBag.newInstance(config); + configNew.configure(LocationConfigKeys.DISPLAY_NAME, (String)configExtra.get(LocationConfigKeys.DISPLAY_NAME.getName())); + config = configNew.getAllConfig(); + } + } + } + } + return new LocationSummary( + id, + locationSpec.getName(), + locationSpec.getSpec(), + null, + copyConfig(config, level), + ImmutableMap.of("self", URI.create("/v1/locations/" + id))); + } + + /** @deprecated since 0.7.0 use method taking management context and detail specifier */ + @Deprecated + public static LocationSummary newInstance(LocationDefinition l) { + return newInstance(null, l, LocationDetailLevel.LOCAL_EXCLUDING_SECRET); + } + + public static LocationSummary newInstance(ManagementContext mgmt, LocationDefinition l, LocationDetailLevel level) { + // TODO: Can remove null checks on mgmt when newInstance(LocationDefinition) is deleted + Map<String, Object> config = l.getConfig(); + if (mgmt != null && (level==LocationDetailLevel.FULL_EXCLUDING_SECRET || level==LocationDetailLevel.FULL_INCLUDING_SECRET)) { + Location ll = mgmt.getLocationRegistry().resolve(l, false, null).orNull(); + if (ll!=null) config = ((LocationInternal)ll).config().getBag().getAllConfig(); + } else if (level==LocationDetailLevel.LOCAL_EXCLUDING_SECRET) { + // get displayName + if (mgmt != null && !config.containsKey(LocationConfigKeys.DISPLAY_NAME.getName())) { + Location ll = mgmt.getLocationRegistry().resolve(l, false, null).orNull(); + if (ll!=null) { + Map<String, Object> configExtra = ((LocationInternal)ll).config().getBag().getAllConfig(); + if (configExtra.containsKey(LocationConfigKeys.DISPLAY_NAME.getName())) { + ConfigBag configNew = ConfigBag.newInstance(config); + configNew.configure(LocationConfigKeys.DISPLAY_NAME, (String)configExtra.get(LocationConfigKeys.DISPLAY_NAME.getName())); + config = configNew.getAllConfig(); + } + } + } + } + + return new LocationSummary( + l.getId(), + l.getName(), + l.getSpec(), + null, + copyConfig(config, level), + ImmutableMap.of("self", URI.create("/v1/locations/" + l.getId()))); + } + + private static Map<String, ?> copyConfig(Map<String,?> entries, LocationDetailLevel level) { + ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder(); + if (level!=LocationDetailLevel.NONE) { + for (Map.Entry<String,?> entry : entries.entrySet()) { + if (level==LocationDetailLevel.FULL_INCLUDING_SECRET || !Sanitizer.IS_SECRET_PREDICATE.apply(entry.getKey())) { + builder.put(entry.getKey(), WebResourceUtils.getValueForDisplay(entry.getValue(), true, false)); + } + } + } + return builder.build(); + } + + public static LocationSummary newInstance(ManagementContext mgmt, Location l, LocationDetailLevel level) { + String spec = null; + String specId = null; + Location lp = l; + while (lp!=null && (spec==null || specId==null)) { + // walk parent locations + // TODO not sure this is the best strategy, or if it's needed, as the spec config is inherited anyway... + if (spec==null) { + Maybe<Object> originalSpec = ((LocationInternal)lp).config().getRaw(LocationInternal.ORIGINAL_SPEC); + if (originalSpec.isPresent()) + spec = Strings.toString(originalSpec.get()); + } + if (specId==null) { + LocationDefinition ld = null; + // prefer looking it up by name as this loads the canonical definition + if (spec!=null) ld = mgmt.getLocationRegistry().getDefinedLocationByName(spec); + if (ld==null && spec!=null && spec.startsWith("named:")) + ld = mgmt.getLocationRegistry().getDefinedLocationByName(Strings.removeFromStart(spec, "named:")); + if (ld==null) ld = mgmt.getLocationRegistry().getDefinedLocationById(lp.getId()); + if (ld!=null) { + if (spec==null) spec = ld.getSpec(); + specId = ld.getId(); + } + } + lp = lp.getParent(); + } + if (specId==null && spec!=null) { + // fall back to attempting to lookup it + Location ll = mgmt.getLocationRegistry().resolve(spec, false, null).orNull(); + if (ll!=null) specId = ll.getId(); + } + + Map<String, Object> configOrig; + if (level == LocationDetailLevel.LOCAL_EXCLUDING_SECRET) { + configOrig = MutableMap.copyOf(((LocationInternal)l).config().getLocalBag().getAllConfig()); + } else { + configOrig = MutableMap.copyOf(((LocationInternal)l).config().getBag().getAllConfig()); + } + if (level==LocationDetailLevel.LOCAL_EXCLUDING_SECRET) { + // for LOCAL, also get the display name + if (!configOrig.containsKey(LocationConfigKeys.DISPLAY_NAME.getName())) { + Map<String, Object> configExtra = ((LocationInternal)l).config().getBag().getAllConfig(); + if (configExtra.containsKey(LocationConfigKeys.DISPLAY_NAME.getName())) + configOrig.put(LocationConfigKeys.DISPLAY_NAME.getName(), configExtra.get(LocationConfigKeys.DISPLAY_NAME.getName())); + } + } + Map<String, ?> config = level==LocationDetailLevel.NONE ? null : copyConfig(configOrig, level); + + return new LocationSummary( + l.getId(), + l.getDisplayName(), + spec, + l.getClass().getName(), + config, + MutableMap.of("self", URI.create("/v1/locations/" + l.getId())) + .addIfNotNull("parent", l.getParent()!=null ? URI.create("/v1/locations/"+l.getParent().getId()) : null) + .addIfNotNull("spec", specId!=null ? URI.create("/v1/locations/"+specId) : null) + .asUnmodifiable() ); + } +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/PolicyTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/PolicyTransformer.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/PolicyTransformer.java new file mode 100644 index 0000000..6893633 --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/PolicyTransformer.java @@ -0,0 +1,84 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.rest.transform; + +import java.net.URI; +import java.util.Map; + +import brooklyn.config.ConfigKey; +import brooklyn.entity.Entity; +import brooklyn.entity.basic.EntityLocal; +import brooklyn.policy.Policy; +import brooklyn.policy.basic.Policies; +import brooklyn.rest.domain.ApplicationSummary; +import brooklyn.rest.domain.PolicyConfigSummary; +import brooklyn.rest.domain.PolicySummary; +import org.apache.brooklyn.rest.resources.PolicyConfigResource; +import org.apache.brooklyn.rest.util.BrooklynRestResourceUtils; + +import com.google.common.collect.ImmutableMap; + +/** + * Converts from Brooklyn entities to restful API summary objects + */ +public class PolicyTransformer { + + public static PolicySummary policySummary(Entity entity, Policy policy) { + String applicationUri = "/v1/applications/" + entity.getApplicationId(); + String entityUri = applicationUri + "/entities/" + entity.getId(); + + Map<String, URI> links = ImmutableMap.<String, URI>builder() + .put("self", URI.create(entityUri + "/policies/" + policy.getId())) + .put("config", URI.create(entityUri + "/policies/" + policy.getId() + "/config")) + .put("start", URI.create(entityUri + "/policies/" + policy.getId() + "/start")) + .put("stop", URI.create(entityUri + "/policies/" + policy.getId() + "/stop")) + .put("destroy", URI.create(entityUri + "/policies/" + policy.getId() + "/destroy")) + .put("application", URI.create(applicationUri)) + .put("entity", URI.create(entityUri)) + .build(); + + return new PolicySummary(policy.getId(), policy.getDisplayName(), policy.getCatalogItemId(), ApplicationTransformer.statusFromLifecycle(Policies.getPolicyStatus(policy)), links); + } + + public static PolicyConfigSummary policyConfigSummary(BrooklynRestResourceUtils utils, ApplicationSummary application, EntityLocal entity, Policy policy, ConfigKey<?> config) { + PolicyConfigSummary summary = policyConfigSummary(utils, entity, policy, config); +// TODO +// if (!entity.getApplicationId().equals(application.getInstance().getId())) +// throw new IllegalStateException("Application "+application+" does not match app "+entity.getApplication()+" of "+entity); + return summary; + } + + public static PolicyConfigSummary policyConfigSummary(BrooklynRestResourceUtils utils, EntityLocal entity, Policy policy, ConfigKey<?> config) { + String applicationUri = "/v1/applications/" + entity.getApplicationId(); + String entityUri = applicationUri + "/entities/" + entity.getId(); + String policyUri = entityUri + "/policies/" + policy.getId(); + + Map<String, URI> links = ImmutableMap.<String, URI>builder() + .put("self", URI.create(policyUri + "/config/" + config.getName())) + .put("application", URI.create(applicationUri)) + .put("entity", URI.create(entityUri)) + .put("policy", URI.create(policyUri)) + .build(); + + return new PolicyConfigSummary(config.getName(), config.getTypeName(), config.getDescription(), + PolicyConfigResource.getStringValueForDisplay(utils, policy, config.getDefaultValue()), + config.isReconfigurable(), + links); + } +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/SensorTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/SensorTransformer.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/SensorTransformer.java new file mode 100644 index 0000000..dfa6de0 --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/SensorTransformer.java @@ -0,0 +1,85 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.rest.transform; + +import java.net.URI; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import brooklyn.config.render.RendererHints; +import brooklyn.entity.Entity; +import brooklyn.event.AttributeSensor; +import brooklyn.event.Sensor; +import brooklyn.rest.domain.SensorSummary; +import brooklyn.util.collections.MutableMap; +import brooklyn.util.exceptions.Exceptions; +import brooklyn.util.net.URLParamEncoder; +import brooklyn.util.text.Strings; + +import com.google.common.collect.Iterables; + +public class SensorTransformer { + + private static final Logger log = LoggerFactory.getLogger(SensorTransformer.class); + + public static SensorSummary sensorSummaryForCatalog(Sensor<?> sensor) { + return new SensorSummary(sensor.getName(), sensor.getTypeName(), + sensor.getDescription(), null); + } + + public static SensorSummary sensorSummary(Entity entity, Sensor<?> sensor) { + String applicationUri = "/v1/applications/" + entity.getApplicationId(); + String entityUri = applicationUri + "/entities/" + entity.getId(); + String selfUri = entityUri + "/sensors/" + URLParamEncoder.encode(sensor.getName()); + + MutableMap.Builder<String, URI> lb = MutableMap.<String, URI>builder() + .put("self", URI.create(selfUri)) + .put("application", URI.create(applicationUri)) + .put("entity", URI.create(entityUri)) + .put("action:json", URI.create(selfUri)); + + if (sensor instanceof AttributeSensor) { + Iterable<RendererHints.NamedAction> hints = Iterables.filter(RendererHints.getHintsFor((AttributeSensor<?>)sensor), RendererHints.NamedAction.class); + for (RendererHints.NamedAction na : hints) addNamedAction(lb, na , entity, sensor); + } + + return new SensorSummary(sensor.getName(), sensor.getTypeName(), sensor.getDescription(), lb.build()); + } + + private static <T> void addNamedAction(MutableMap.Builder<String, URI> lb, RendererHints.NamedAction na , Entity entity, Sensor<T> sensor) { + addNamedAction(lb, na, entity.getAttribute( ((AttributeSensor<T>) sensor) ), sensor, entity); + } + + @SuppressWarnings("unchecked") + static <T> void addNamedAction(MutableMap.Builder<String, URI> lb, RendererHints.NamedAction na, T value, Object context, Entity contextEntity) { + if (na instanceof RendererHints.NamedActionWithUrl) { + try { + String v = ((RendererHints.NamedActionWithUrl<T>) na).getUrlFromValue(value); + if (Strings.isNonBlank(v)) { + String action = na.getActionName().toLowerCase(); + lb.putIfAbsent("action:"+action, URI.create(v)); + } + } catch (Exception e) { + Exceptions.propagateIfFatal(e); + log.warn("Unable to make action "+na+" from "+context+" on "+contextEntity+": "+e, e); + } + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/TaskTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/TaskTransformer.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/TaskTransformer.java new file mode 100644 index 0000000..50b07e8 --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/transform/TaskTransformer.java @@ -0,0 +1,147 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.rest.transform; + +import java.net.URI; +import java.net.URISyntaxException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import javax.annotation.Nullable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import brooklyn.entity.Entity; +import brooklyn.entity.basic.BrooklynTaskTags; +import brooklyn.entity.basic.BrooklynTaskTags.WrappedStream; +import brooklyn.management.HasTaskChildren; +import brooklyn.management.Task; +import brooklyn.rest.domain.LinkWithMetadata; +import brooklyn.rest.domain.TaskSummary; +import org.apache.brooklyn.rest.util.WebResourceUtils; +import brooklyn.util.collections.MutableMap; +import brooklyn.util.exceptions.Exceptions; +import brooklyn.util.task.TaskInternal; +import brooklyn.util.text.Strings; + +import com.google.common.base.Function; +import com.google.common.base.Preconditions; + +public class TaskTransformer { + + @SuppressWarnings("unused") + private static final Logger log = LoggerFactory.getLogger(TaskTransformer.class); + + public static final Function<Task<?>, TaskSummary> FROM_TASK = new Function<Task<?>, TaskSummary>() { + @Override + public TaskSummary apply(@Nullable Task<?> input) { + return taskSummary(input); + } + }; + + public static TaskSummary taskSummary(Task<?> task) { + try { + Preconditions.checkNotNull(task); + Entity entity = BrooklynTaskTags.getContextEntity(task); + String entityId; + String entityDisplayName; + URI entityLink; + + String selfLink = asLink(task).getLink(); + + if (entity != null) { + entityId = entity.getId(); + entityDisplayName = entity.getDisplayName(); + entityLink = new URI("/v1/applications/"+entity.getApplicationId()+"/"+"entities"+"/"+entity.getId()); + } else { + entityId = null; + entityDisplayName = null; + entityLink = null; + } + + List<LinkWithMetadata> children = Collections.emptyList(); + if (task instanceof HasTaskChildren) { + children = new ArrayList<LinkWithMetadata>(); + for (Task<?> t: ((HasTaskChildren)task).getChildren()) { + children.add(asLink(t)); + } + } + + Map<String,LinkWithMetadata> streams = new MutableMap<String, LinkWithMetadata>(); + for (WrappedStream stream: BrooklynTaskTags.streams(task)) { + MutableMap<String, Object> metadata = MutableMap.<String,Object>of("name", stream.streamType); + if (stream.streamSize.get()!=null) { + metadata.add("size", stream.streamSize.get()); + metadata.add("sizeText", Strings.makeSizeString(stream.streamSize.get())); + } + String link = selfLink+"/stream/"+stream.streamType; + streams.put(stream.streamType, new LinkWithMetadata(link, metadata)); + } + + Map<String,URI> links = MutableMap.of("self", new URI(selfLink), + "children", new URI(selfLink+"/"+"children")); + if (entityLink!=null) links.put("entity", entityLink); + + Object result; + try { + if (task.isDone()) { + result = WebResourceUtils.getValueForDisplay(task.get(), true, false); + } else { + result = null; + } + } catch (Throwable t) { + result = Exceptions.collapseText(t); + } + + return new TaskSummary(task.getId(), task.getDisplayName(), task.getDescription(), entityId, entityDisplayName, + task.getTags(), ifPositive(task.getSubmitTimeUtc()), ifPositive(task.getStartTimeUtc()), ifPositive(task.getEndTimeUtc()), + task.getStatusSummary(), result, task.isError(), task.isCancelled(), + children, asLink(task.getSubmittedByTask()), + task.isDone() ? null : task instanceof TaskInternal ? asLink(((TaskInternal<?>)task).getBlockingTask()) : null, + task.isDone() ? null : task instanceof TaskInternal ? ((TaskInternal<?>)task).getBlockingDetails() : null, + task.getStatusDetail(true), + streams, + links); + } catch (URISyntaxException e) { + // shouldn't happen + throw Exceptions.propagate(e); + } + } + + private static Long ifPositive(Long time) { + if (time==null || time<=0) return null; + return time; + } + + public static LinkWithMetadata asLink(Task<?> t) { + if (t==null) return null; + MutableMap<String,Object> data = new MutableMap<String,Object>(); + data.put("id", t.getId()); + if (t.getDisplayName()!=null) data.put("taskName", t.getDisplayName()); + Entity entity = BrooklynTaskTags.getContextEntity(t); + if (entity!=null) { + data.put("entityId", entity.getId()); + if (entity.getDisplayName()!=null) data.put("entityDisplayName", entity.getDisplayName()); + } + return new LinkWithMetadata("/v1/activities/"+t.getId(), data); + } +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/a9e5ca55/usage/rest-server/src/main/java/org/apache/brooklyn/rest/util/BrooklynRestResourceUtils.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/org/apache/brooklyn/rest/util/BrooklynRestResourceUtils.java b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/util/BrooklynRestResourceUtils.java new file mode 100644 index 0000000..11df7b5 --- /dev/null +++ b/usage/rest-server/src/main/java/org/apache/brooklyn/rest/util/BrooklynRestResourceUtils.java @@ -0,0 +1,564 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.rest.util; + +import static org.apache.brooklyn.rest.util.WebResourceUtils.notFound; +import static com.google.common.collect.Iterables.transform; +import groovy.lang.GroovyClassLoader; + +import java.lang.reflect.Constructor; +import java.net.URI; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Set; +import java.util.concurrent.Future; + +import javax.ws.rs.core.MediaType; +import javax.ws.rs.core.Response; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import brooklyn.basic.BrooklynTypes; +import org.apache.brooklyn.catalog.BrooklynCatalog; +import org.apache.brooklyn.catalog.CatalogItem; +import brooklyn.catalog.internal.CatalogUtils; +import brooklyn.config.ConfigKey; +import brooklyn.enricher.Enrichers; +import brooklyn.entity.Application; +import brooklyn.entity.Entity; +import brooklyn.entity.basic.AbstractEntity; +import brooklyn.entity.basic.ApplicationBuilder; +import brooklyn.entity.basic.Attributes; +import brooklyn.entity.basic.BasicApplication; +import brooklyn.entity.basic.Entities; +import brooklyn.entity.basic.EntityInternal; +import brooklyn.entity.basic.EntityLocal; +import brooklyn.entity.trait.Startable; +import brooklyn.location.Location; +import brooklyn.location.LocationRegistry; +import brooklyn.management.ManagementContext; +import brooklyn.management.Task; +import brooklyn.management.entitlement.Entitlements; +import brooklyn.management.entitlement.Entitlements.StringAndArgument; +import brooklyn.policy.Policy; +import brooklyn.policy.basic.AbstractPolicy; +import brooklyn.rest.domain.ApplicationSpec; +import brooklyn.rest.domain.EntitySpec; +import brooklyn.util.collections.MutableMap; +import brooklyn.util.exceptions.Exceptions; +import brooklyn.util.flags.TypeCoercions; +import brooklyn.util.javalang.Reflections; +import brooklyn.util.net.Urls; +import brooklyn.util.text.Strings; + +import com.google.common.base.Function; +import com.google.common.base.Preconditions; +import com.google.common.base.Predicate; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.io.Files; + +public class BrooklynRestResourceUtils { + + private static final Logger log = LoggerFactory.getLogger(BrooklynRestResourceUtils.class); + + private final ManagementContext mgmt; + + public BrooklynRestResourceUtils(ManagementContext mgmt) { + Preconditions.checkNotNull(mgmt, "mgmt"); + this.mgmt = mgmt; + } + + public BrooklynCatalog getCatalog() { + return mgmt.getCatalog(); + } + + public ClassLoader getCatalogClassLoader() { + return mgmt.getCatalogClassLoader(); + } + + public LocationRegistry getLocationRegistry() { + return mgmt.getLocationRegistry(); + } + + /** finds the policy indicated by the given ID or name. + * @see {@link #getEntity(String,String)}; it then searches the policies of that + * entity for one whose ID or name matches that given. + * <p> + * + * @throws 404 or 412 (unless input is null in which case output is null) */ + public Policy getPolicy(String application, String entity, String policy) { + return getPolicy(getEntity(application, entity), policy); + } + + /** finds the policy indicated by the given ID or name. + * @see {@link #getPolicy(String,String,String)}. + * <p> + * + * @throws 404 or 412 (unless input is null in which case output is null) */ + public Policy getPolicy(Entity entity, String policy) { + if (policy==null) return null; + + for (Policy p: entity.getPolicies()) { + if (policy.equals(p.getId())) return p; + } + for (Policy p: entity.getPolicies()) { + if (policy.equals(p.getDisplayName())) return p; + } + + throw WebResourceUtils.notFound("Cannot find policy '%s' in entity '%s'", policy, entity); + } + + /** finds the entity indicated by the given ID or name + * <p> + * prefers ID based lookup in which case appId is optional, and if supplied will be enforced. + * optionally the name can be supplied, for cases when paths should work across versions, + * in which case names will be searched recursively (and the application is required). + * + * @throws 404 or 412 (unless input is null in which case output is null) */ + public EntityLocal getEntity(String application, String entity) { + if (entity==null) return null; + Application app = application!=null ? getApplication(application) : null; + EntityLocal e = (EntityLocal) mgmt.getEntityManager().getEntity(entity); + + if (e!=null) { + if (!Entitlements.isEntitled(mgmt.getEntitlementManager(), Entitlements.SEE_ENTITY, e)) { + throw WebResourceUtils.notFound("Cannot find entity '%s': no known ID and application not supplied for searching", entity); + } + + if (app==null || app.equals(findTopLevelApplication(e))) return e; + throw WebResourceUtils.preconditionFailed("Application '%s' specified does not match application '%s' to which entity '%s' (%s) is associated", + application, e.getApplication()==null ? null : e.getApplication().getId(), entity, e); + } + if (application==null) + throw WebResourceUtils.notFound("Cannot find entity '%s': no known ID and application not supplied for searching", entity); + + assert app!=null : "null app should not be returned from getApplication"; + e = searchForEntityNamed(app, entity); + if (e!=null) return e; + throw WebResourceUtils.notFound("Cannot find entity '%s' in application '%s' (%s)", entity, application, app); + } + + private Application findTopLevelApplication(Entity e) { + // For nested apps, e.getApplication() can return its direct parent-app rather than the root app + // (particularly if e.getApplication() was called before the parent-app was wired up to its parent, + // because that call causes the application to be cached). + // Therefore we continue to walk the hierarchy until we find an "orphaned" application at the top. + + Application app = e.getApplication(); + while (app != null && !app.equals(app.getApplication())) { + app = app.getApplication(); + } + return app; + } + + /** looks for the given application instance, first by ID then by name + * + * @throws 404 if not found, or not entitled + */ + public Application getApplication(String application) { + Entity e = mgmt.getEntityManager().getEntity(application); + if (!Entitlements.isEntitled(mgmt.getEntitlementManager(), Entitlements.SEE_ENTITY, e)) { + throw notFound("Application '%s' not found", application); + } + + if (e != null && e instanceof Application) return (Application) e; + for (Application app : mgmt.getApplications()) { + if (app.getId().equals(application)) return app; + if (application.equalsIgnoreCase(app.getDisplayName())) return app; + } + + throw notFound("Application '%s' not found", application); + } + + /** walks the hierarchy (depth-first) at root (often an Application) looking for + * an entity matching the given ID or name; returns the first such entity, or null if none found + **/ + public EntityLocal searchForEntityNamed(Entity root, String entity) { + if (root.getId().equals(entity) || entity.equals(root.getDisplayName())) return (EntityLocal) root; + for (Entity child: root.getChildren()) { + Entity result = searchForEntityNamed(child, entity); + if (result!=null) return (EntityLocal) result; + } + return null; + } + + @SuppressWarnings({ "unchecked", "deprecation" }) + 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; + final String catalogItemId; + if (Strings.isEmpty(type)) { + clazz = BasicApplication.class; + catalogItemId = null; + } else { + Class<? extends Entity> tempclazz; + BrooklynCatalog catalog = getCatalog(); + CatalogItem<?, ?> item = catalog.getCatalogItemForType(type); + if (item != null) { + catalogItemId = item.getId(); + tempclazz = (Class<? extends Entity>) catalog.loadClass(item); + } else { + catalogItemId = null; + try { + tempclazz = (Class<? extends Entity>) catalog.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 new NoSuchElementException("Unable to find catalog item for type "+type); + } + } + 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, catalogItemId); + 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, catalogItemId); + configureRenderingMetadata(spec, coreSpec); + + instance = (Application) mgmt.getEntityManager().createEntity(coreSpec); + + Entity soleChild = mgmt.getEntityManager().createEntity(toCoreEntitySpec(clazz, name, configO, catalogItemId)); + instance.addChild(soleChild); + instance.addEnricher(Enrichers.builder() + .propagatingAllBut(Attributes.SERVICE_UP, Attributes.SERVICE_NOT_UP_INDICATORS, + Attributes.SERVICE_STATE_ACTUAL, Attributes.SERVICE_STATE_EXPECTED, + Attributes.SERVICE_PROBLEMS) + .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); + } + + public Task<?> start(Application app, ApplicationSpec spec) { + return start(app, getLocations(spec)); + } + + public Task<?> start(Application app, List<? extends Location> locations) { + return Entities.invokeEffector((EntityLocal)app, app, Startable.START, + MutableMap.of("locations", locations)); + } + + public List<Location> getLocations(ApplicationSpec spec) { + // Start all the managed entities by asking the app instance to start in background + Function<String, Location> buildLocationFromId = new Function<String, Location>() { + @Override + public Location apply(String id) { + id = fixLocation(id); + return getLocationRegistry().resolve(id); + } + }; + + ArrayList<Location> locations = Lists.newArrayList(transform(spec.getLocations(), buildLocationFromId)); + return locations; + } + + @SuppressWarnings({ "unchecked", "deprecation" }) + private brooklyn.entity.proxying.EntitySpec<? extends Entity> toCoreEntitySpec(brooklyn.rest.domain.EntitySpec spec) { + String type = spec.getType(); + String name = spec.getName(); + Map<String, String> config = (spec.getConfig() == null) ? Maps.<String,String>newLinkedHashMap() : Maps.newLinkedHashMap(spec.getConfig()); + + BrooklynCatalog catalog = getCatalog(); + CatalogItem<?, ?> item = catalog.getCatalogItemForType(type); + Class<? extends Entity> tempclazz; + final String catalogItemId; + if (item != null) { + tempclazz = (Class<? extends Entity>) catalog.loadClass(item); + catalogItemId = item.getId(); + } else { + catalogItemId = null; + try { + tempclazz = (Class<? extends Entity>) catalog.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 new NoSuchElementException("Unable to find catalog item for type "+type); + } + } + final Class<? extends Entity> clazz = tempclazz; + brooklyn.entity.proxying.EntitySpec<? extends Entity> result; + if (clazz.isInterface()) { + result = brooklyn.entity.proxying.EntitySpec.create(clazz); + } else { + result = brooklyn.entity.proxying.EntitySpec.create(Entity.class).impl(clazz).additionalInterfaces(Reflections.getAllInterfaces(clazz)); + } + result.catalogItemId(catalogItemId); + if (!Strings.isEmpty(name)) result.displayName(name); + result.configure( convertFlagsToKeys(result.getType(), config) ); + configureRenderingMetadata(spec, result); + return result; + } + + protected void configureRenderingMetadata(ApplicationSpec spec, ApplicationBuilder appBuilder) { + appBuilder.configure(getRenderingConfigurationFor(spec.getType())); + } + + protected void configureRenderingMetadata(ApplicationSpec input, brooklyn.entity.proxying.EntitySpec<?> entity) { + entity.configure(getRenderingConfigurationFor(input.getType())); + } + + protected void configureRenderingMetadata(EntitySpec input, brooklyn.entity.proxying.EntitySpec<?> entity) { + entity.configure(getRenderingConfigurationFor(input.getType())); + } + + protected Map<?, ?> getRenderingConfigurationFor(String catalogId) { + MutableMap<Object, Object> result = MutableMap.of(); + CatalogItem<?,?> item = CatalogUtils.getCatalogItemOptionalVersion(mgmt, catalogId); + if (item==null) return result; + + result.addIfNotNull("iconUrl", item.getIconUrl()); + return result; + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private <T extends Entity> brooklyn.entity.proxying.EntitySpec<?> toCoreEntitySpec(Class<T> clazz, String name, Map<String,String> configO, String catalogItemId) { + Map<String, String> config = (configO == null) ? Maps.<String,String>newLinkedHashMap() : Maps.newLinkedHashMap(configO); + + brooklyn.entity.proxying.EntitySpec<? extends Entity> result; + if (clazz.isInterface()) { + result = brooklyn.entity.proxying.EntitySpec.create(clazz); + } else { + // If this is a concrete class, particularly for an Application class, we want the proxy + // to expose all interfaces it implements. + Class interfaceclazz = (Application.class.isAssignableFrom(clazz)) ? Application.class : Entity.class; + Set<Class<?>> additionalInterfaceClazzes = Reflections.getInterfacesIncludingClassAncestors(clazz); + result = brooklyn.entity.proxying.EntitySpec.create(interfaceclazz).impl(clazz).additionalInterfaces(additionalInterfaceClazzes); + } + + result.catalogItemId(catalogItemId); + if (!Strings.isEmpty(name)) result.displayName(name); + result.configure( convertFlagsToKeys(result.getImplementation(), config) ); + return result; + } + + private Map<?,?> convertFlagsToKeys(Class<? extends Entity> javaType, Map<?, ?> config) { + if (config==null || config.isEmpty() || javaType==null) return config; + + Map<String, ConfigKey<?>> configKeys = BrooklynTypes.getDefinedConfigKeys(javaType); + Map<Object,Object> result = new LinkedHashMap<Object,Object>(); + for (Map.Entry<?,?> entry: config.entrySet()) { + log.debug("Setting key {} to {} for REST creation of {}", new Object[] { entry.getKey(), entry.getValue(), javaType}); + Object key = configKeys.get(entry.getKey()); + if (key==null) { + log.warn("Unrecognised config key {} passed to {}; will be treated as flag (and likely ignored)", entry.getKey(), javaType); + key = entry.getKey(); + } + result.put(key, entry.getValue()); + } + return result; + } + + public Task<?> destroy(final Application application) { + return mgmt.getExecutionManager().submit( + MutableMap.of("displayName", "destroying "+application, + "description", "REST call to destroy application "+application.getDisplayName()+" ("+application+")"), + new Runnable() { + @Override + public void run() { + ((EntityInternal)application).destroy(); + mgmt.getEntityManager().unmanage(application); + } + }); + } + + public Task<?> expunge(final Entity entity, final boolean release) { + if (mgmt.getEntitlementManager().isEntitled(Entitlements.getEntitlementContext(), + Entitlements.INVOKE_EFFECTOR, Entitlements.EntityAndItem.of(entity, + StringAndArgument.of("expunge", MutableMap.of("release", release))))) { + return mgmt.getExecutionManager().submit( + MutableMap.of("displayName", "expunging " + entity, "description", "REST call to expunge entity " + + entity.getDisplayName() + " (" + entity + ")"), new Runnable() { + @Override + public void run() { + if (release) + Entities.destroyCatching(entity); + else + mgmt.getEntityManager().unmanage(entity); + } + }); + } + throw WebResourceUtils.unauthorized("User '%s' is not authorized to expunge entity %s", + Entitlements.getEntitlementContext().user(), entity); + } + + + @Deprecated + @SuppressWarnings({ "rawtypes" }) + public Response createCatalogEntryFromGroovyCode(String groovyCode) { + ClassLoader parent = getCatalog().getRootClassLoader(); + @SuppressWarnings("resource") + GroovyClassLoader loader = new GroovyClassLoader(parent); + + Class clazz = loader.parseClass(groovyCode); + + if (AbstractEntity.class.isAssignableFrom(clazz)) { + CatalogItem<?,?> item = getCatalog().addItem(clazz); + log.info("REST created "+item); + return Response.created(URI.create("entities/" + clazz.getName())).build(); + + } else if (AbstractPolicy.class.isAssignableFrom(clazz)) { + CatalogItem<?,?> item = getCatalog().addItem(clazz); + log.info("REST created "+item); + return Response.created(URI.create("policies/" + clazz.getName())).build(); + } + + throw WebResourceUtils.preconditionFailed("Unsupported type superclass "+clazz.getSuperclass()+"; expects Entity or Policy"); + } + + @Deprecated + public static String fixLocation(String locationId) { + if (locationId.startsWith("/v1/locations/")) { + log.warn("REST API using legacy URI syntax for location: "+locationId); + locationId = Strings.removeFromStart(locationId, "/v1/locations/"); + } + return locationId; + } + + public Object getObjectValueForDisplay(Object value) { + if (value==null) return null; + // currently everything converted to string, expanded if it is a "done" future + if (value instanceof Future) { + if (((Future<?>)value).isDone()) { + try { + value = ((Future<?>)value).get(); + } catch (Exception e) { + value = ""+value+" (error evaluating: "+e+")"; + } + } + } + + if (TypeCoercions.isPrimitiveOrBoxer(value.getClass())) return value; + return value.toString(); + } + + // currently everything converted to string, expanded if it is a "done" future + public String getStringValueForDisplay(Object value) { + if (value==null) return null; + return ""+getObjectValueForDisplay(value); + } + + /** true if the URL points to content which must be resolved on the server-side (i.e. classpath) + * and which is safe to do so (currently just images, though in future perhaps also javascript and html plugins) + * <p> + * note we do not let caller access classpath through this mechanism, + * just those which are supplied by the platform administrator e.g. as an icon url */ + public boolean isUrlServerSideAndSafe(String url) { + if (Strings.isEmpty(url)) return false; + String ext = Files.getFileExtension(url); + if (Strings.isEmpty(ext)) return false; + MediaType mime = WebResourceUtils.getImageMediaTypeFromExtension(ext); + if (mime==null) return false; + + return !Urls.isUrlWithProtocol(url) || url.startsWith("classpath:"); + } + + + public Iterable<Entity> descendantsOfAnyType(String application, String entity) { + List<Entity> result = Lists.newArrayList(); + EntityLocal e = getEntity(application, entity); + gatherAllDescendants(e, result); + return result; + } + + private static void gatherAllDescendants(Entity e, List<Entity> result) { + if (result.add(e)) { + for (Entity ee: e.getChildren()) + gatherAllDescendants(ee, result); + } + } + + public Iterable<Entity> descendantsOfType(String application, String entity, final String typeRegex) { + Iterable<Entity> result = descendantsOfAnyType(application, entity); + return Iterables.filter(result, new Predicate<Entity>() { + @Override + public boolean apply(Entity entity) { + if (entity==null) return false; + return (entity.getEntityType().getName().matches(typeRegex)); + } + }); + } + + public void reloadBrooklynProperties() { + mgmt.reloadBrooklynProperties(); + } +}
