Add series of meta effectors for composite operations

core/src/main/java/org/apache/brooklyn/core/effector/AddChildrenEffector.java

@@ -35,17 +35,17 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.google.common.annotations.Beta;
 import com.google.common.collect.Iterables;
 
-/** Entity initializer which defines an effector which adds a child blueprint to an entity.
+/**
+ * Entity initializer which defines an effector which adds a child blueprint to an entity.
  * <p>
  * One of the config keys {@link #BLUEPRINT_YAML} (containing a YAML blueprint (map or string)) 
  * or {@link #BLUEPRINT_TYPE} (containing a string referring to a catalog type) should be supplied, but not both.
  * Parameters defined here are supplied as config during the entity creation.
  * 
- * @since 0.7.0 */
-@Beta
+ * @since 0.7.0
+ */
 public class AddChildrenEffector extends AddEffector {
 
     private static final Logger log = LoggerFactory.getLogger(AddChildrenEffector.class);

core/src/main/java/org/apache/brooklyn/core/effector/AddEffector.java

@@ -54,31 +54,31 @@
  * are only those supplied by a user at runtime; in order to merge with default
  * values, use {@link #getMergedParams(Effector, ConfigBag)}.
  *  
- * @since 0.7.0 */
-@Beta
+ * @since 0.7.0
+ */
 public class AddEffector implements EntityInitializer {
-    
+
     public static final ConfigKey<String> EFFECTOR_NAME = ConfigKeys.newStringConfigKey("name");
     public static final ConfigKey<String> EFFECTOR_DESCRIPTION = ConfigKeys.newStringConfigKey("description");
-    
+
     public static final ConfigKey<Map<String,Object>> EFFECTOR_PARAMETER_DEFS = new MapConfigKey<Object>(Object.class, "parameters");
 
-    final Effector<?> effector;
-    
+    protected final Effector<?> effector;
+
     public AddEffector(Effector<?> effector) {
         this.effector = Preconditions.checkNotNull(effector, "effector");
     }
-    
+
     @Override
     public void apply(EntityLocal entity) {
         ((EntityInternal)entity).getMutableEntityType().addEffector(effector);
     }
-    
+
     public static <T> EffectorBuilder<T> newEffectorBuilder(Class<T> type, ConfigBag params) {
         String name = Preconditions.checkNotNull(params.get(EFFECTOR_NAME), "name must be supplied when defining an effector: %s", params);
         EffectorBuilder<T> eff = Effectors.effector(type, name);
         eff.description(params.get(EFFECTOR_DESCRIPTION));
-        
+
         Map<String, Object> paramDefs = params.get(EFFECTOR_PARAMETER_DEFS);
         if (paramDefs!=null) {
             for (Map.Entry<String, Object> paramDef: paramDefs.entrySet()){
@@ -97,7 +97,7 @@ public static <T> EffectorBuilder<T> newEffectorBuilder(Class<T> type, ConfigBag
                 }
             }
         }
-        
+
         return eff;
     }
 

core/src/main/java/org/apache/brooklyn/core/effector/AddSensor.java

@@ -20,112 +20,20 @@
 
 import java.util.Map;
 
-import org.apache.brooklyn.api.entity.Entity;
-import org.apache.brooklyn.api.entity.EntityInitializer;
-import org.apache.brooklyn.api.entity.EntityLocal;
-import org.apache.brooklyn.api.sensor.AttributeSensor;
-import org.apache.brooklyn.config.ConfigKey;
-import org.apache.brooklyn.core.config.ConfigKeys;
-import org.apache.brooklyn.core.entity.EntityInternal;
-import org.apache.brooklyn.core.sensor.Sensors;
-import org.apache.brooklyn.util.core.ClassLoaderUtils;
 import org.apache.brooklyn.util.core.config.ConfigBag;
-import org.apache.brooklyn.util.guava.Maybe;
-import org.apache.brooklyn.util.javalang.Boxing;
-import org.apache.brooklyn.util.time.Duration;
-
-import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
 
 /**
- * Creates a new {@link AttributeSensor} on an entity.
- * <p>
- * The configuration can include the sensor {@code name}, {@code period} and {@code targetType}.
- * For the targetType, currently this only supports classes on the initial classpath, not those in
- * OSGi bundles added at runtime.
- *
- * @since 0.7.0
+ * @deprecated use {@link org.apache.brooklyn.core.sensor.AddSensor} instead
  */
-@Beta
-public class AddSensor<T> implements EntityInitializer {
-
-    public static final ConfigKey<String> SENSOR_NAME = ConfigKeys.newStringConfigKey("name", "The name of the sensor to create");
-    public static final ConfigKey<Duration> SENSOR_PERIOD = ConfigKeys.newConfigKey(Duration.class, "period", "Period, including units e.g. 1m or 5s or 200ms; default 5 minutes", Duration.FIVE_MINUTES);
-    public static final ConfigKey<String> SENSOR_TYPE = ConfigKeys.newStringConfigKey("targetType", "Target type for the value; default String", "java.lang.String");
-
-    protected final String name;
-    protected final Duration period;
-    protected final String type;
-    protected AttributeSensor<T> sensor;
-    protected final ConfigBag params;
+@Deprecated
+public class AddSensor<T> extends org.apache.brooklyn.core.sensor.AddSensor<T> {
 
     public AddSensor(Map<String, String> params) {
-        this(ConfigBag.newInstance(params));
+        super(params);
     }
 
     public AddSensor(final ConfigBag params) {
-        this.name = Preconditions.checkNotNull(params.get(SENSOR_NAME), "Name must be supplied when defining a sensor");
-        this.period = params.get(SENSOR_PERIOD);
-        this.type = params.get(SENSOR_TYPE);
-        this.params = params;
-    }
-
-    @Override
-    public void apply(EntityLocal entity) {
-        sensor = newSensor(entity);
-        ((EntityInternal) entity).getMutableEntityType().addSensor(sensor);
-    }
-
-    private AttributeSensor<T> newSensor(Entity entity) {
-        String className = getFullClassName(type);
-        Class<T> clazz = getType(entity, className);
-        return Sensors.newSensor(clazz, name);
-    }
-
-    @SuppressWarnings("unchecked")
-    protected Class<T> getType(Entity entity, String className) {
-        try {
-            // TODO use OSGi loader (low priority however); also ensure that allows primitives
-            Maybe<Class<?>> primitive = Boxing.getPrimitiveType(className);
-            if (primitive.isPresent()) return (Class<T>) primitive.get();
-
-            return (Class<T>) new ClassLoaderUtils(this, entity).loadClass(className);
-        } catch (ClassNotFoundException e) {
-            if (!className.contains(".")) {
-                // could be assuming "java.lang" package; try again with that
-                try {
-                    return (Class<T>) Class.forName("java.lang."+className);
-                } catch (ClassNotFoundException e2) {
-                    throw new IllegalArgumentException("Invalid target type for sensor "+name+": " + className+" (also tried java.lang."+className+")");
-                }
-            } else {
-                throw new IllegalArgumentException("Invalid target type for sensor "+name+": " + className);
-            }
-        }
-    }
-
-    protected String getFullClassName(String className) {
-        if (className.equalsIgnoreCase("string")) {
-            return "java.lang.String";
-        } else if (className.equalsIgnoreCase("int") || className.equalsIgnoreCase("integer")) {
-            return "java.lang.Integer";
-        } else if (className.equalsIgnoreCase("long")) {
-            return "java.lang.Long";
-        } else if (className.equalsIgnoreCase("float")) {
-            return "java.lang.Float";
-        } else if (className.equalsIgnoreCase("double")) {
-            return "java.lang.Double";
-        } else if (className.equalsIgnoreCase("bool") || className.equalsIgnoreCase("boolean")) {
-            return "java.lang.Boolean";
-        } else if (className.equalsIgnoreCase("byte")) {
-            return "java.lang.Byte";
-        } else if (className.equalsIgnoreCase("char") || className.equalsIgnoreCase("character")) {
-            return "java.lang.Character";
-        } else if (className.equalsIgnoreCase("object")) {
-            return "java.lang.Object";
-        } else {
-            return className;
-        }
+        super(params);
     }
 
-}
+}

core/src/main/java/org/apache/brooklyn/core/effector/CompositeEffector.java

@@ -29,6 +29,8 @@
 import org.apache.brooklyn.config.ConfigKey;
 import org.apache.brooklyn.core.config.ConfigKeys;
 import org.apache.brooklyn.core.effector.Effectors.EffectorBuilder;
+import org.apache.brooklyn.core.effector.composite.ReplaceEffector;
+import org.apache.brooklyn.core.effector.composite.SequenceEffector;
 import org.apache.brooklyn.core.entity.EntityInitializers;
 import org.apache.brooklyn.core.entity.EntityInternal;
 import org.apache.brooklyn.util.core.config.ConfigBag;
@@ -42,7 +44,11 @@
 import com.google.common.collect.Lists;
 import com.google.common.reflect.TypeToken;
 
+/**
+ * @deprecated use a combintaion of {@link ReplaceEffector} and {@link SequenceEffector} instead
+ */
 @Beta
+@Deprecated
 public class CompositeEffector extends AddEffector {
 
     private static final Logger LOG = LoggerFactory.getLogger(CompositeEffector.class);

core/src/main/java/org/apache/brooklyn/core/effector/RemoveEntityEffector.java

@@ -0,0 +1,106 @@
+/*
+ * 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.core.effector;
+
+import java.util.Map;
+
+import org.apache.brooklyn.api.effector.Effector;
+import org.apache.brooklyn.api.entity.Entity;
+import org.apache.brooklyn.config.ConfigKey;
+import org.apache.brooklyn.core.config.ConfigKeys;
+import org.apache.brooklyn.core.effector.Effectors.EffectorBuilder;
+import org.apache.brooklyn.core.entity.EntityInitializers;
+import org.apache.brooklyn.core.entity.EntityPredicates;
+import org.apache.brooklyn.util.core.config.ConfigBag;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.annotations.Beta;
+import com.google.common.base.Optional;
+import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
+import com.google.common.reflect.TypeToken;
+
+/**
+ * @since 0.11.0
+ */
+@Beta
+public class RemoveEntityEffector extends AddEffector {
+
+    private static final Logger LOG = LoggerFactory.getLogger(RemoveEntityEffector.class);
+
+    public static final ConfigKey<String> ENTITY_ID = ConfigKeys.builder(String.class)
+            .name("entityId")
+            .description("The id of the entity to be removed")
+            .build();
+
+    public static final ConfigKey<Predicate<Entity>> ENTITY_PREDICATE = ConfigKeys.builder(new TypeToken<Predicate<Entity>>() { })
+            .name("predicate")
+            .description("A predicate that will match the entity to be removed")
+            .build();
+
+    public RemoveEntityEffector(ConfigBag params) {
+        super(newEffectorBuilder(params).build());
+    }
+
+    public RemoveEntityEffector(Map<String,String> params) {
+        this(ConfigBag.newInstance(params));
+    }
+
+    public static EffectorBuilder<Boolean> newEffectorBuilder(ConfigBag params) {
+        EffectorBuilder<Boolean> eff = (EffectorBuilder) AddEffector.newEffectorBuilder(Boolean.class, params);
+        eff.impl(new Body(eff.buildAbstract(), params));
+        return eff;
+    }
+
+    protected static class Body extends EffectorBody<Boolean> {
+        protected final Effector<?> effector;
+        protected final ConfigBag config;
+
+        protected Object mutex = new Object[0];
+
+        public Body(Effector<?> eff, ConfigBag config) {
+            this.effector = eff;
+            this.config = config;
+        }
+
+        @Override
+        public Boolean call(final ConfigBag params) {
+            synchronized (mutex) {
+                ConfigBag all = ConfigBag.newInstanceCopying(config).putAll(params);
+                Predicate<Entity> predicate = EntityInitializers.resolve(all, ENTITY_PREDICATE);
+                if (predicate == null) {
+                    String entityId = EntityInitializers.resolve(all, ENTITY_ID);
+                    predicate = EntityPredicates.idEqualTo(entityId);
+                }
+                Optional<Entity> child = Iterables.tryFind(entity().getChildren(), predicate);
+                if (child.isPresent()) {
+                    boolean success = entity().removeChild(child.get());
+                    if (success) {
+                        LOG.debug("{}: Removed child {} from {}", new Object[] { this, child.get(), entity() });
+                        return true;
+                    }
+                }
+                LOG.warn("{}: Could not find child of {} using {}", new Object[] { this, entity(), predicate });
+                return false;
+            }
+        }
+    }
+
+}