Redesigned the manageables.

rapidoid-commons/src/main/java/org/rapidoid/group/AbstractManageable.java

@@ -29,21 +29,28 @@
 import org.rapidoid.cls.Cls;
 import org.rapidoid.cls.TypeKind;
 import org.rapidoid.commons.Str;
+import org.rapidoid.concurrent.Callback;
+import org.rapidoid.concurrent.Callbacks;
+import org.rapidoid.concurrent.Promise;
+import org.rapidoid.concurrent.Promises;
+import org.rapidoid.log.Log;
 import org.rapidoid.u.U;
 
 import java.lang.reflect.Method;
 import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeoutException;
 
 @Authors("Nikolche Mihajlovski")
 @Since("5.3.0")
 public abstract class AbstractManageable extends RapidoidThing implements Manageable {
 
 	@Override
 	public Object runManageableAction(String action) {
-		Method method = Cls.findMethod(getClass(), Str.uncapitalized(action));
+		Method method = Cls.findMethod(source().getClass(), Str.uncapitalized(action));
 
 		if (method != null) {
-			return Cls.invoke(method, this);
+			return Cls.invoke(method, source());
 
 		} else {
 			return doManageableAction(action);
@@ -54,7 +61,7 @@ public Object runManageableAction(String action) {
 	public List<String> getManageableActions() {
 		List<String> actions = U.list();
 
-		for (Method method : Cls.getMethodsAnnotated(getClass(), Action.class)) {
+		for (Method method : Cls.getMethodsAnnotated(source().getClass(), Action.class)) {
 			Action action = method.getAnnotation(Action.class);
 			actions.add(!action.name().isEmpty() ? action.name() : method.getName());
 		}
@@ -64,7 +71,7 @@ public List<String> getManageableActions() {
 
 	@Override
 	public List<String> getManageableProperties() {
-		BeanProperties props = Beany.propertiesOf(this);
+		BeanProperties props = Beany.propertiesOf(source());
 
 		List<String> ps = U.list();
 
@@ -82,8 +89,48 @@ public List<String> getManageableProperties() {
 		return ps;
 	}
 
+	protected Object source() {
+		return this;
+	}
+
+	@Override
+	public Map<String, List<Manageable>> getManageableChildren() {
+		return U.map();
+	}
+
 	protected Object doManageableAction(String action) {
 		throw U.rte("Cannot handle action '%s'!", action);
 	}
 
+	@Override
+	public GroupOf<? extends Manageable> group() {
+		return null;
+	}
+
+	@Override
+	public String kind() {
+		return Manageables.kindOf(source().getClass());
+	}
+
+	protected void doReloadManageable(Callback<Void> callback) {
+		Callbacks.done(callback, null, null);
+	}
+
+	@Override
+	public final void reloadManageable() {
+		final Promise<Void> promise = Promises.create();
+
+		doReloadManageable(promise);
+
+		try {
+			promise.get(5000);
+		} catch (TimeoutException e) {
+			Log.error("Couldn't reload the manageable!", e);
+		}
+	}
+
+	@Override
+	public Object getManageableDisplay() {
+		return null;
+	}
 }

rapidoid-commons/src/main/java/org/rapidoid/group/AutoManageable.java

@@ -24,7 +24,6 @@
 import org.rapidoid.annotation.Since;
 import org.rapidoid.collection.Coll;
 import org.rapidoid.lambda.Mapper;
-import org.rapidoid.u.U;
 
 import java.util.Map;
 import java.util.UUID;
@@ -36,7 +35,7 @@ public abstract class AutoManageable<T extends AutoManageable> extends AbstractM
 	private static final Map<Class<? extends Manageable>, GroupOf<? extends Manageable>> GROUPS = Coll.autoExpandingMap(new Mapper<Class<? extends Manageable>, GroupOf<? extends Manageable>>() {
 		@Override
 		public GroupOf<?> map(Class<? extends Manageable> cls) throws Exception {
-			return new GroupOf<>(cls, "default");
+			return new GroupOf<>(cls);
 		}
 	});
 
@@ -67,4 +66,7 @@ public String id() {
 		return id;
 	}
 
+	public static void reset() {
+		GROUPS.clear();
+	}
 }

rapidoid-commons/src/main/java/org/rapidoid/group/GroupOf.java

@@ -33,37 +33,24 @@
 @Since("5.3.0")
 public class GroupOf<E extends Manageable> extends RapidoidThing {
 
-	private static String kindOf(Class<? extends Manageable> cls) {
-		ManageableBean mb = cls.getAnnotation(ManageableBean.class);
-		U.must(mb != null, "The type '%s' must be annotated with @%s", ManageableBean.class.getSimpleName());
-		return mb.kind();
-	}
-
 	private final String kind;
 
 	private final Class<E> itemType;
 
-	private final String name;
-
 	private final List<E> items = Coll.synchronizedList();
 
 	private final GroupStats stats = new GroupStats();
 
-	public GroupOf(Class<E> itemType, String name) {
-		this.kind = kindOf(itemType);
+	public GroupOf(Class<E> itemType) {
+		this.kind = Manageables.kindOf(itemType);
 		this.itemType = itemType;
-		this.name = name;
 		Groups.ALL.add(this);
 	}
 
 	public String kind() {
 		return kind;
 	}
 
-	public String name() {
-		return name;
-	}
-
 	public Class<E> itemType() {
 		return itemType;
 	}
@@ -165,7 +152,7 @@ public boolean contains(E element) {
 	@Override
 	public String toString() {
 		return "GroupOf{" +
-			"name='" + name + '\'' +
+			"kind='" + kind + '\'' +
 			", size=" + items.size() +
 			", stats=" + stats +
 			'}';
@@ -178,15 +165,14 @@ public boolean equals(Object o) {
 
 		GroupOf<?> groupOf = (GroupOf<?>) o;
 
-		if (!itemType.equals(groupOf.itemType)) return false;
-		return name.equals(groupOf.name);
+		if (kind != null ? !kind.equals(groupOf.kind) : groupOf.kind != null) return false;
+		return itemType != null ? itemType.equals(groupOf.itemType) : groupOf.itemType == null;
 	}
 
 	@Override
 	public int hashCode() {
-		int result = itemType.hashCode();
-		result = 31 * result + name.hashCode();
+		int result = kind != null ? kind.hashCode() : 0;
+		result = 31 * result + (itemType != null ? itemType.hashCode() : 0);
 		return result;
 	}
-
 }

rapidoid-commons/src/main/java/org/rapidoid/group/Groups.java

@@ -40,16 +40,6 @@ public static Set<GroupOf<?>> all() {
 		return Collections.unmodifiableSet(U.set(ALL)); // snapshot
 	}
 
-	@SuppressWarnings("unchecked")
-	public static <T extends Manageable> GroupOf<T> find(Class<T> itemType, String name) {
-		for (GroupOf<?> group : all()) {
-			if (group.itemType().equals(itemType) && group.name().equals(name)) {
-				return (GroupOf<T>) group;
-			}
-		}
-		return null;
-	}
-
 	@SuppressWarnings("unchecked")
 	public static <T extends Manageable> List<GroupOf<T>> find(Class<? extends T> itemType) {
 		List<GroupOf<T>> groups = U.list();
@@ -76,34 +66,11 @@ public static <T extends Manageable> List<GroupOf<T>> find(String kind) {
 		return groups;
 	}
 
-	public static <T extends Manageable> T findMember(Class<? extends T> itemType, String id) {
-
-		for (GroupOf<T> group : find(itemType)) {
-			T member = group.find(id);
-			if (member != null) {
-				return member;
-			}
-		}
-
-		return null;
-	}
-
-	public static Manageable findMember(String itemType, String id) {
-
-		for (GroupOf<Manageable> group : find(itemType)) {
-			Manageable member = group.find(id);
-			if (member != null) {
-				return member;
-			}
-		}
-
-		return null;
-	}
-
 	public static void reset() {
 		for (GroupOf<?> group : all()) {
 			group.clear();
 		}
 		ALL.clear();
+		AutoManageable.reset();
 	}
 }

rapidoid-commons/src/main/java/org/rapidoid/group/Manageable.java

@@ -24,19 +24,28 @@
 import org.rapidoid.annotation.Since;
 
 import java.util.List;
+import java.util.Map;
 
 @Authors("Nikolche Mihajlovski")
 @Since("5.3.0")
 public interface Manageable {
 
 	String id();
 
+	String kind();
+
 	GroupOf<? extends Manageable> group();
 
+	void reloadManageable();
+
 	List<String> getManageableActions();
 
 	List<String> getManageableProperties();
 
+	Map<String, List<Manageable>> getManageableChildren();
+
 	Object runManageableAction(String action);
 
+	Object getManageableDisplay();
+
 }

rapidoid-commons/src/main/java/org/rapidoid/group/Manageables.java

@@ -0,0 +1,104 @@
+package org.rapidoid.group;
+
+import org.rapidoid.RapidoidThing;
+import org.rapidoid.annotation.Authors;
+import org.rapidoid.annotation.Since;
+import org.rapidoid.u.U;
+
+import java.util.List;
+
+/*
+ * #%L
+ * rapidoid-commons
+ * %%
+ * Copyright (C) 2014 - 2017 Nikolche Mihajlovski and contributors
+ * %%
+ * Licensed 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.
+ * #L%
+ */
+
+@Authors("Nikolche Mihajlovski")
+@Since("5.3.5")
+public class Manageables extends RapidoidThing {
+
+	public static String kindOf(Class<?> cls) {
+		ManageableBean mb = cls.getAnnotation(ManageableBean.class);
+		U.must(mb != null, "The type '%s' must be annotated with @%s", ManageableBean.class.getSimpleName());
+		return mb.kind();
+	}
+
+	public static <T extends Manageable> T find(Class<? extends T> itemType, String id) {
+
+		for (GroupOf<T> group : Groups.find(itemType)) {
+			T member = group.find(id);
+			if (member != null) {
+				return member;
+			}
+		}
+
+		return null;
+	}
+
+	public static Manageable find(String itemType, String id) {
+
+		for (GroupOf<Manageable> group : Groups.find(itemType)) {
+			Manageable member = group.find(id);
+			if (member != null) {
+				return member;
+			}
+		}
+
+		return null;
+	}
+
+	public static Manageable find(String kind, String id, String sub) {
+
+		Manageable target = find(kind, id);
+		U.must(target != null, "Cannot find the manageable!");
+		target.reloadManageable();
+
+		if (U.isEmpty(sub)) {
+			return target;
+		}
+
+		return findSub(target, sub);
+	}
+
+	private static Manageable findSub(Manageable target, String sub) {
+
+		String[] parts = sub.split("/", 3);
+		String seg = parts[0];
+		String id = parts[1];
+
+		List<? extends Manageable> segment = target.getManageableChildren().get(seg);
+		U.must(segment != null, "Cannot find the manageable segment: %s", seg);
+
+		target = findById(segment, id);
+		U.must(target != null, "Cannot find the sub-manageable with id: %s in segment: %s", id, seg);
+
+		target.reloadManageable();
+
+		return parts.length > 2 ? findSub(target, parts[2]) : target;
+	}
+
+	private static Manageable findById(List<? extends Manageable> items, String id) {
+		U.notNull(id, "id");
+
+		for (Manageable item : items) {
+			if (U.eq(id, item.id())) return item;
+		}
+
+		return null;
+	}
+
+}

rapidoid-commons/src/main/java/org/rapidoid/process/ProcessParams.java

@@ -36,7 +36,7 @@ public class ProcessParams extends RapidoidThing {
 
 	private volatile String[] command;
 
-	private volatile Processes group = Processes.DEFAULT;
+	private volatile Processes group = Processes.GROUP;
 
 	private volatile boolean printingOutput;