Adding ability to easily create name thread factories with threads belonging to …

…hierarchical thread groups.

Change-Id: Iaab3251c13e14b73c54a8edc945f5aa476a7ca54

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * 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.
+ */
+package org.onlab.util;
+
+import org.apache.commons.lang3.concurrent.ConcurrentUtils;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ThreadFactory;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+
+/**
+ * Thread factory for creating threads that belong to the specified thread group.
+ */
+public final class GroupedThreadFactory implements ThreadFactory {
+
+    public static final String DELIMITER = "/";
+
+    private final ThreadGroup group;
+
+    // Cache of created thread factories.
+    private static final ConcurrentHashMap<String, GroupedThreadFactory> FACTORIES =
+            new ConcurrentHashMap<>();
+
+    /**
+     * Returns thread factory for producing threads associated with the specified
+     * group name. The group name-space is hierarchical, based on slash-delimited
+     * name segments, e.g. {@code onos/intent}.
+     *
+     * @param groupName group name
+     * @return thread factory
+     */
+    public static GroupedThreadFactory groupedThreadFactory(String groupName) {
+        GroupedThreadFactory factory = FACTORIES.get(groupName);
+        if (factory != null) {
+            return factory;
+        }
+
+        // Find the parent group or root the group hierarchy under default group.
+        int i = groupName.lastIndexOf(DELIMITER);
+        if (i > 0) {
+            String name = groupName.substring(0, i);
+            ThreadGroup parentGroup = groupedThreadFactory(name).threadGroup();
+            factory = new GroupedThreadFactory(new ThreadGroup(parentGroup, groupName));
+        } else {
+            factory = new GroupedThreadFactory(new ThreadGroup(groupName));
+        }
+
+        return ConcurrentUtils.putIfAbsent(FACTORIES, groupName, factory);
+    }
+
+    // Creates a new thread group
+    private GroupedThreadFactory(ThreadGroup group) {
+        this.group = group;
+    }
+
+    /**
+     * Returns the thread group associated with the factory.
+     *
+     * @return thread group
+     */
+    public ThreadGroup threadGroup() {
+        return group;
+    }
+
+    @Override
+    public Thread newThread(Runnable r) {
+        return new Thread(group, r);
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this).add("group", group).toString();
+    }
+}

@@ -15,16 +15,16 @@
  */
  */
 package org.onlab.util;
 package org.onlab.util;
 
 
-import static java.nio.file.Files.delete;
-import static java.nio.file.Files.walkFileTree;
-import static org.slf4j.LoggerFactory.getLogger;
+import com.google.common.base.Strings;
+import com.google.common.primitives.UnsignedLongs;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import org.slf4j.Logger;
 
 
 import java.io.BufferedReader;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.InputStreamReader;
-import java.lang.Thread.UncaughtExceptionHandler;
 import java.nio.charset.StandardCharsets;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.FileVisitResult;
 import java.nio.file.FileVisitResult;
 import java.nio.file.Files;
 import java.nio.file.Files;
@@ -38,11 +38,10 @@ import java.util.Collection;
 import java.util.List;
 import java.util.List;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.ThreadFactory;
 
 
-import org.slf4j.Logger;
-
-import com.google.common.base.Strings;
-import com.google.common.primitives.UnsignedLongs;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import static java.nio.file.Files.delete;
+import static java.nio.file.Files.walkFileTree;
+import static org.onlab.util.GroupedThreadFactory.groupedThreadFactory;
+import static org.slf4j.LoggerFactory.getLogger;
 
 
 public abstract class Tools {
 public abstract class Tools {
 
 
@@ -62,13 +61,25 @@ public abstract class Tools {
         return new ThreadFactoryBuilder()
         return new ThreadFactoryBuilder()
                 .setNameFormat(pattern)
                 .setNameFormat(pattern)
                         // FIXME remove UncaughtExceptionHandler before release
                         // FIXME remove UncaughtExceptionHandler before release
-                .setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+                .setUncaughtExceptionHandler((t, e) -> log.error("Uncaught exception on {}", t.getName(), e)).build();
+    }
 
 
-                    @Override
-                    public void uncaughtException(Thread t, Throwable e) {
-                        log.error("Uncaught exception on {}", t.getName(), e);
-                    }
-                }).build();
+    /**
+     * Returns a thread factory that produces threads named according to the
+     * supplied name pattern and from the specified thread-group. The thread
+     * group name is expected to be specified in slash-delimited format, e.g.
+     * {@code onos/intent}.
+     *
+     * @param groupName group name in slash-delimited format to indicate hierarchy
+     * @param pattern   name pattern
+     * @return thread factory
+     */
+    public static ThreadFactory groupedThreads(String groupName, String pattern) {
+        return new ThreadFactoryBuilder()
+                .setThreadFactory(groupedThreadFactory(groupName))
+                .setNameFormat(pattern)
+                        // FIXME remove UncaughtExceptionHandler before release
+                .setUncaughtExceptionHandler((t, e) -> log.error("Uncaught exception on {}", t.getName(), e)).build();
     }
     }
 
 
     /**
     /**

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * 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.
+ */
+package org.onlab.util;
+
+import org.junit.Test;
+import org.onlab.junit.TestTools;
+
+import static org.junit.Assert.*;
+
+/**
+ * Tests of the group thread factory.
+ */
+public class GroupedThreadFactoryTest {
+
+    @Test
+    public void basics() {
+        GroupedThreadFactory a = GroupedThreadFactory.groupedThreadFactory("foo");
+        GroupedThreadFactory b = GroupedThreadFactory.groupedThreadFactory("foo");
+        assertSame("factories should be same", a, b);
+
+        assertTrue("wrong toString", a.toString().contains("foo"));
+        Thread t = a.newThread(() -> TestTools.print("yo"));
+        assertSame("wrong group", a.threadGroup(), t.getThreadGroup());
+    }
+
+    @Test
+    public void hierarchical() {
+        GroupedThreadFactory a = GroupedThreadFactory.groupedThreadFactory("foo/bar");
+        GroupedThreadFactory b = GroupedThreadFactory.groupedThreadFactory("foo/goo");
+        GroupedThreadFactory p = GroupedThreadFactory.groupedThreadFactory("foo");
+
+        assertSame("groups should be same", p.threadGroup(), a.threadGroup().getParent());
+        assertSame("groups should be same", p.threadGroup(), b.threadGroup().getParent());
+
+        assertEquals("wrong name", "foo/bar", a.threadGroup().getName());
+        assertEquals("wrong name", "foo/goo", b.threadGroup().getName());
+        assertEquals("wrong name", "foo", p.threadGroup().getName());
+    }
+
+}
\ No newline at end of file

@@ -16,6 +16,9 @@
 package org.onlab.util;
 package org.onlab.util;
 
 
 import org.junit.Test;
 import org.junit.Test;
+import org.onlab.junit.TestTools;
+
+import java.util.concurrent.ThreadFactory;
 
 
 import static org.junit.Assert.*;
 import static org.junit.Assert.*;
 
 
@@ -42,4 +45,20 @@ public class ToolsTest {
         assertEquals("ffffffffffffffff", Tools.toHex(0xffffffffffffffffL));
         assertEquals("ffffffffffffffff", Tools.toHex(0xffffffffffffffffL));
 
 
     }
     }
+
+    @Test
+    public  void namedThreads() {
+        ThreadFactory f = Tools.namedThreads("foo-%d");
+        Thread t = f.newThread(() -> TestTools.print("yo"));
+        assertTrue("wrong pattern", t.getName().startsWith("foo-"));
+    }
+
+    @Test
+    public  void groupedThreads() {
+        ThreadFactory f = Tools.groupedThreads("foo/bar", "foo-%d");
+        Thread t = f.newThread(() -> TestTools.print("yo"));
+        assertTrue("wrong pattern", t.getName().startsWith("foo-"));
+        assertTrue("wrong group", t.getThreadGroup().getName().equals("foo/bar"));
+    }
+
 }
 }