def load_extensions(self, group, name_filter=None, comp_filter=None, class_filter=None, product_name=None, unique=False):
        found_extensions = []
        if product_name is not None:
            for comp in self.iter_components():
                if comp_filter is not None and comp.name != comp_filter:
                    continue
                products = comp.find_products(product_name)
                for product in products:
                    try:
                        entries = self.load_extension(product, name_filter=name_filter, class_filter=class_filter,
                                                      component=comp)
                        if len(entries) == 0 and name_filter is None:
                            self._logger.warn("Found no valid extensions in product %s of component %s",
                                              product, comp.path)
                            continue
                        found_extensions.extend(entries)
                    except:
                        self._logger.exception("Unable to load extension %s from local component %s at path %s",
                                               product_name, comp, product)
        for entry in self._iter_entrypoint_group(group):
            name = entry.name
            if name_filter is not None and name != name_filter:
                continue
            try:
                ext = entry.load()
            except:
                self._logger.warn("Unable to load %s from %s", entry.name, entry.distro, exc_info=True)
                continue
            found_extensions.extend((name, x) for x in self._filter_subclasses(ext, class_filter))
        for (name, ext) in self._registered_extensions.get(group, []):
            if name_filter is not None and name != name_filter:
                continue
            found_extensions.extend((name, x) for x in self._filter_subclasses(ext, class_filter))
        found_extensions = [(name, x) for name, x in found_extensions if self._filter_nonextensions(x)]
        if unique is True:
            if len(found_extensions) > 1:
                raise ArgumentError("Extension %s should have had exactly one instance of class %s, found %d" % (group, class_filter.__name__, len(found_extensions)), classes=found_extensions)
            elif len(found_extensions) == 0:
                raise ArgumentError("Extension %s had no instances of class %s" % (group, class_filter.__name__))
            return found_extensions[0]
        return found_extensions