You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@brooklyn.apache.org by he...@apache.org on 2022/12/08 00:24:54 UTC

[brooklyn-server] branch master updated (86dfbb0932 -> c961ccbc85)

This is an automated email from the ASF dual-hosted git repository.

heneveld pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/brooklyn-server.git


    from 86dfbb0932 support (partially) openssh key format
     new 6b9837a768 use containing bundle as part of the search path, and prefer the search path
     new 2f429a1c0d allow kind to change during validation
     new c961ccbc85 updates to tests where same-bundle and library wasn't used for searching

The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../classloading/BrooklynClassLoadingContext.java  |   5 +
 .../catalog/CatalogMakeOsgiBundleTest.java         |   4 +-
 .../catalog/CatalogOsgiVersionMoreEntityTest.java  |  14 +-
 .../catalog/CatalogOsgiYamlLocationTest.java       |   5 +-
 .../camp/brooklyn/catalog/CatalogScanOsgiTest.java |  40 +++---
 .../catalog/NestedRefsCatalogYamlTest.java         | 151 +++++++++++++++------
 .../camp/brooklyn/test/lite/CampYamlLiteTest.java  |  22 +--
 ...ml => nested-refs-catalog-yaml-test-2.bom.yaml} |  13 +-
 ...ml => nested-refs-catalog-yaml-test-3.bom.yaml} |   6 +-
 .../catalog/internal/BasicBrooklynCatalog.java     | 104 ++++++++------
 .../BrooklynClassLoadingContextSequential.java     |  21 ++-
 .../JavaBrooklynClassLoadingContext.java           |  10 +-
 .../OsgiBrooklynClassLoadingContext.java           |   2 +
 .../resolve/entity/CatalogEntitySpecResolver.java  |   4 +-
 ...BrooklynRegisteredTypeJacksonSerialization.java |   3 +-
 .../core/typereg/BasicBrooklynTypeRegistry.java    |   2 +-
 .../brooklyn/core/typereg/RegisteredTypes.java     |  31 ++++-
 .../rest/resources/BundleAndTypeResourcesTest.java |  12 +-
 .../rest/resources/CatalogResourceTest.java        |   4 +-
 .../rt/felix/EmbeddedFelixFrameworkTest.java       |   7 +-
 20 files changed, 301 insertions(+), 159 deletions(-)
 copy camp/camp-brooklyn/src/test/resources/{nested-refs-catalog-yaml-test.bom.yaml => nested-refs-catalog-yaml-test-2.bom.yaml} (95%)
 copy camp/camp-brooklyn/src/test/resources/{nested-refs-catalog-yaml-test.bom.yaml => nested-refs-catalog-yaml-test-3.bom.yaml} (95%)


[brooklyn-server] 03/03: updates to tests where same-bundle and library wasn't used for searching

Posted by he...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

heneveld pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/brooklyn-server.git

commit c961ccbc85375004fb31191206789431cd5d3f33
Author: Alex Heneveld <al...@cloudsoft.io>
AuthorDate: Thu Dec 8 00:15:12 2022 +0000

    updates to tests where same-bundle and library wasn't used for searching
---
 .../catalog/CatalogMakeOsgiBundleTest.java         |  4 +--
 .../catalog/CatalogOsgiVersionMoreEntityTest.java  | 14 ++++----
 .../catalog/CatalogOsgiYamlLocationTest.java       |  5 +--
 .../camp/brooklyn/catalog/CatalogScanOsgiTest.java | 40 +++++++++-------------
 .../camp/brooklyn/test/lite/CampYamlLiteTest.java  | 22 +++++++-----
 .../catalog/internal/BasicBrooklynCatalog.java     |  6 +++-
 .../rest/resources/BundleAndTypeResourcesTest.java | 12 +++----
 .../rest/resources/CatalogResourceTest.java        |  4 +--
 .../rt/felix/EmbeddedFelixFrameworkTest.java       |  7 ++--
 9 files changed, 60 insertions(+), 54 deletions(-)

diff --git a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogMakeOsgiBundleTest.java b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogMakeOsgiBundleTest.java
index 122c4a088d..975fa07336 100644
--- a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogMakeOsgiBundleTest.java
+++ b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogMakeOsgiBundleTest.java
@@ -149,8 +149,8 @@ public class CatalogMakeOsgiBundleTest extends AbstractYamlTest {
         
         RegisteredType item = mgmt().getTypeRegistry().get( basic1.getCatalogItemId() );
         Collection<OsgiBundleWithUrl> libs = item.getLibraries();
-        Asserts.assertSize(libs, 1);
-        Assert.assertEquals(Iterables.getOnlyElement(libs).getSymbolicName(), customName);
+        Asserts.assertSize(libs, 2);
+        Assert.assertEquals(MutableList.copyOf(libs).get(1).getSymbolicName(), customName);
     }
 
     private void installBundle(File jf) {
diff --git a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogOsgiVersionMoreEntityTest.java b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogOsgiVersionMoreEntityTest.java
index 600e7d619e..ef2deb319d 100644
--- a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogOsgiVersionMoreEntityTest.java
+++ b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogOsgiVersionMoreEntityTest.java
@@ -101,7 +101,7 @@ public class CatalogOsgiVersionMoreEntityTest extends AbstractYamlTest implement
         Assert.assertNotNull(item);
         Assert.assertEquals(item.getVersion(), "1.0");
         Assert.assertTrue(RegisteredTypePredicates.IS_ENTITY.apply(item));
-        Assert.assertEquals(item.getLibraries().size(), 1);
+        Assert.assertEquals(item.getLibraries().size(), 2);
         
         Entity app = createAndStartApplication("services: [ { type: 'more-entity:1.0' } ]");
         Entity moreEntity = Iterables.getOnlyElement(app.getChildren());
@@ -151,20 +151,20 @@ public class CatalogOsgiVersionMoreEntityTest extends AbstractYamlTest implement
     }
 
     @Test
-    /** Now assumes highest version wins regardless of install order */
-    public void testMoreEntityV1AndV2GivesV2() throws Exception {
+    /** Uses libraries to find references */
+    public void testMoreEntityV2ThenV1GivesV1() throws Exception {
         TestResourceUnavailableException.throwIfResourceUnavailable(getClass(), "/brooklyn/osgi/brooklyn-test-osgi-more-entities_0.1.0.jar");
         TestResourceUnavailableException.throwIfResourceUnavailable(getClass(), "/brooklyn/osgi/brooklyn-test-osgi-more-entities_0.2.0.jar");
         TestResourceUnavailableException.throwIfResourceUnavailable(getClass(), "/brooklyn/osgi/brooklyn-test-osgi-entities.jar");
 
-        addCatalogItems(getLocalResource("more-entity-v2-osgi-catalog.yaml"));
+        addCatalogItems(getLocalResource("more-entity-v2-osgi-catalog.yaml"));  // expects MoreEntity to come from 0.2.0 bundle, installed as more-entity:1.0
         forceCatalogUpdate();
-        addCatalogItems(getLocalResource("more-entity-v1-osgi-catalog.yaml"));
+        addCatalogItems(getLocalResource("more-entity-v1-osgi-catalog.yaml"));  // expects MoreEntity to come from 0.1.0 bundle, installed as more-entity:1.0; replaces previous
         Entity app = createAndStartApplication("services: [ { type: 'more-entity:1.0' } ]");
         Entity moreEntity = Iterables.getOnlyElement(app.getChildren());
         
-        OsgiVersionMoreEntityTest.assertV2EffectorCall(moreEntity);
-        OsgiVersionMoreEntityTest.assertV2MethodCall(moreEntity);
+        OsgiVersionMoreEntityTest.assertV1EffectorCall(moreEntity);
+        OsgiVersionMoreEntityTest.assertV1MethodCall(moreEntity);
     }
 
     /** unlike {@link #testMoreEntityV2ThenV1GivesV1()} this test should always work,
diff --git a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogOsgiYamlLocationTest.java b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogOsgiYamlLocationTest.java
index 8f94f0e6f7..a7bf9407da 100644
--- a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogOsgiYamlLocationTest.java
+++ b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogOsgiYamlLocationTest.java
@@ -37,6 +37,7 @@ import org.apache.brooklyn.core.mgmt.osgi.OsgiStandaloneTest;
 import org.apache.brooklyn.core.typereg.RegisteredTypePredicates;
 import org.apache.brooklyn.core.typereg.RegisteredTypes;
 import org.apache.brooklyn.test.support.TestResourceUnavailableException;
+import org.apache.brooklyn.util.collections.MutableList;
 import org.apache.brooklyn.util.text.StringFunctions;
 import org.testng.Assert;
 import org.testng.annotations.AfterMethod;
@@ -99,8 +100,8 @@ public class CatalogOsgiYamlLocationTest extends AbstractYamlTest {
     private void assertOsgi(String symbolicName) {
         RegisteredType item = mgmt().getTypeRegistry().get(symbolicName, TEST_VERSION);
         Collection<OsgiBundleWithUrl> libs = item.getLibraries();
-        assertEquals(libs.size(), 1);
-        assertEquals(Iterables.getOnlyElement(libs).getUrl(), Iterables.getOnlyElement(getOsgiLibraries()));
+        assertEquals(libs.size(), 2);
+        assertEquals(MutableList.copyOf(libs).get(1).getUrl(), Iterables.getOnlyElement(getOsgiLibraries()));
     }
 
     private void assertAdded(String symbolicName, String expectedJavaType) {
diff --git a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogScanOsgiTest.java b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogScanOsgiTest.java
index 97986514a7..796bfa0a16 100644
--- a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogScanOsgiTest.java
+++ b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/CatalogScanOsgiTest.java
@@ -18,32 +18,16 @@
  */
 package org.apache.brooklyn.camp.brooklyn.catalog;
 
-import java.util.function.Predicate;
+import com.google.common.collect.Iterables;
 import org.apache.brooklyn.api.entity.EntitySpec;
-import org.apache.brooklyn.core.config.ConfigKeys;
-import org.apache.brooklyn.core.mgmt.ha.OsgiBundleInstallationResult;
-import org.apache.brooklyn.core.mgmt.ha.OsgiBundleInstallationResult.ResultCode;
-import org.apache.brooklyn.util.exceptions.Exceptions;
-import org.apache.brooklyn.util.stream.InputStreamSource;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import static org.testng.Assert.assertEquals;
-
-import java.io.ByteArrayInputStream;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.util.Map;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipOutputStream;
-
 import org.apache.brooklyn.api.mgmt.ManagementContext;
 import org.apache.brooklyn.api.typereg.ManagedBundle;
 import org.apache.brooklyn.api.typereg.RegisteredType;
 import org.apache.brooklyn.camp.brooklyn.AbstractYamlTest;
 import org.apache.brooklyn.camp.brooklyn.test.lite.CampYamlLiteTest;
+import org.apache.brooklyn.core.config.ConfigKeys;
+import org.apache.brooklyn.core.mgmt.ha.OsgiBundleInstallationResult;
+import org.apache.brooklyn.core.mgmt.ha.OsgiBundleInstallationResult.ResultCode;
 import org.apache.brooklyn.core.mgmt.internal.ManagementContextInternal;
 import org.apache.brooklyn.entity.stock.BasicEntity;
 import org.apache.brooklyn.test.Asserts;
@@ -52,14 +36,24 @@ import org.apache.brooklyn.util.collections.MutableMap;
 import org.apache.brooklyn.util.collections.MutableSet;
 import org.apache.brooklyn.util.core.ResourceUtils;
 import org.apache.brooklyn.util.core.osgi.BundleMaker;
+import org.apache.brooklyn.util.exceptions.Exceptions;
 import org.apache.brooklyn.util.os.Os;
 import org.apache.brooklyn.util.osgi.OsgiTestResources;
+import org.apache.brooklyn.util.stream.InputStreamSource;
 import org.apache.brooklyn.util.stream.Streams;
 import org.apache.brooklyn.util.text.Strings;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
-import com.google.common.collect.Iterables;
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import static org.testng.Assert.assertEquals;
 
 public class CatalogScanOsgiTest extends AbstractYamlTest {
 
@@ -108,13 +102,13 @@ public class CatalogScanOsgiTest extends AbstractYamlTest {
 
         RegisteredType hereItem = mgmt().getTypeRegistry().get("here-item");
         assertEquals(hereItem.getVersion(), "2.0-test_java");
-        Asserts.assertSize(hereItem.getLibraries(), 2);
+        Asserts.assertSize(hereItem.getLibraries(), 3);
         assertEquals(hereItem.getContainingBundle(), "test-items:2.0-test_java");
         
         RegisteredType item = mgmt().getTypeRegistry().get(OsgiTestResources.BROOKLYN_TEST_MORE_ENTITIES_MORE_ENTITY);
         // versions and libraries _are_ inherited in this legacy mode
         assertEquals(item.getVersion(), "2.0-test_java");
-        Asserts.assertSize(hereItem.getLibraries(), 2);
+        Asserts.assertSize(hereItem.getLibraries(), 3);
         // and the containing bundle is recorded as the 
         assertEquals(item.getContainingBundle(), "test-items"+":"+"2.0-test_java");
     }
diff --git a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/test/lite/CampYamlLiteTest.java b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/test/lite/CampYamlLiteTest.java
index 32114ebf86..3598913036 100644
--- a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/test/lite/CampYamlLiteTest.java
+++ b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/test/lite/CampYamlLiteTest.java
@@ -25,6 +25,7 @@ import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.util.Collection;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
@@ -59,6 +60,7 @@ import org.apache.brooklyn.test.support.TestResourceUnavailableException;
 import org.apache.brooklyn.util.collections.MutableMap;
 import org.apache.brooklyn.util.core.ResourceUtils;
 import org.apache.brooklyn.util.core.config.ConfigBag;
+import org.apache.brooklyn.util.osgi.VersionedName;
 import org.apache.brooklyn.util.stream.Streams;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -172,11 +174,7 @@ public class CampYamlLiteTest {
         RegisteredType retrievedItem = Iterables.getOnlyElement(retrievedItems);
         Assert.assertEquals(retrievedItem.getVersion(), "0.9");
 
-        Collection<OsgiBundleWithUrl> bundles = retrievedItem.getLibraries();
-        Asserts.assertSize(bundles, 1);
-        OsgiBundleWithUrl bundle = Iterables.getOnlyElement(bundles);
-        Assert.assertEquals(bundle.getUrl(), OsgiStandaloneTest.BROOKLYN_TEST_OSGI_ENTITIES_URL);
-        Assert.assertEquals(bundle.getSuppliedVersionString(), "0.1.0");
+        assertTwoLibraries(retrievedItem.getLibraries(), VersionedName.fromString(retrievedItem.getContainingBundle()).toOsgiString(), OsgiStandaloneTest.BROOKLYN_TEST_OSGI_ENTITIES_URL);
     }
 
     @Test
@@ -230,10 +228,7 @@ public class CampYamlLiteTest {
         Assert.assertTrue(planYaml.contains("io.camp.mock:AppServer"));
 
         // and let's check we have libraries
-        Collection<OsgiBundleWithUrl> libs = item.getLibraries();
-        assertEquals(libs.size(), 1);
-        OsgiBundleWithUrl bundle = Iterables.getOnlyElement(libs);
-        assertEquals(bundle.getUrl(), bundleUrl);
+        assertTwoLibraries(item.getLibraries(), "my.catalog.app.id:0.1.2", bundleUrl);
 
         // now let's check other things on the item
         assertEquals(item.getDisplayName(), "My Catalog App");
@@ -245,4 +240,13 @@ public class CampYamlLiteTest {
         assertEquals(iconData.length, 43);
     }
 
+    private void assertTwoLibraries(Collection<OsgiBundleWithUrl> libraries, String containingBundle, String bundleUrl) {
+        Iterator<OsgiBundleWithUrl> libi = libraries.iterator();
+        Asserts.assertEquals(libi.next().getVersionedName().toOsgiString(), containingBundle);
+        OsgiBundleWithUrl bundle = libi.next();
+        assertEquals(bundle.getVersionedName().toOsgiString(), "org.apache.brooklyn.test.resources.osgi.brooklyn-test-osgi-entities:0.1.0");
+        assertEquals(bundle.getUrl(), bundleUrl);
+        Asserts.assertFalse(libi.hasNext());
+    }
+
 }
diff --git a/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java b/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java
index fdfb87b253..69e0ff4c24 100644
--- a/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java
+++ b/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java
@@ -33,6 +33,7 @@ import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Queue;
 import java.util.Set;
+import java.util.stream.Collectors;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import org.apache.brooklyn.api.catalog.BrooklynCatalog;
@@ -1886,7 +1887,10 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
 
         Map<RegisteredType, Collection<Throwable>> validation = validateTypes(result.keySet());
         if (Iterables.concat(validation.values()).iterator().hasNext()) {
-            throw new IllegalStateException("Could not validate one or more items: "+validation);
+            log.debug("Detail of failed validation:\n"+
+                    validation.entrySet().stream().map(en -> "  "+en.getKey()+"\n"+en.getValue().stream().map(vv->"    "+Exceptions.collapseText(vv)).collect(Collectors.joining("\n")))
+                            .collect(Collectors.joining("\n")));
+            throw Exceptions.propagate("Could not validate one or more items: "+validation.keySet(), validation.values().stream().flatMap(Collection::stream).collect(Collectors.toList()));
         }
         return result.keySet();
     }
diff --git a/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/BundleAndTypeResourcesTest.java b/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/BundleAndTypeResourcesTest.java
index 96758c362c..c90e2ec3df 100644
--- a/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/BundleAndTypeResourcesTest.java
+++ b/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/BundleAndTypeResourcesTest.java
@@ -184,8 +184,8 @@ public class BundleAndTypeResourcesTest extends BrooklynRestResourceTest {
         RegisteredType item = getManagementContext().getTypeRegistry().get(symbolicName, TEST_VERSION);
         Assert.assertNotNull(item);
         Collection<OsgiBundleWithUrl> libs = item.getLibraries();
-        assertEquals(libs.size(), 1);
-        assertEquals(Iterables.getOnlyElement(libs).getUrl(), bundleUrl);
+        assertEquals(libs.size(), 2);
+        assertEquals(Iterables.get(libs, 1).getUrl(), bundleUrl);
 
         // now let's check other things on the item
         URI expectedIconUrl = URI.create(getEndpointAddress() + "/catalog/types/" + symbolicName + "/" + entityItem.getVersion()+"/icon").normalize();
@@ -727,8 +727,8 @@ public class BundleAndTypeResourcesTest extends BrooklynRestResourceTest {
         RegisteredType item = getManagementContext().getTypeRegistry().get(symbolicName, version);
         Assert.assertNotNull(item);
         Collection<OsgiBundleWithUrl> libs = item.getLibraries();
-        assertEquals(libs.size(), 1);
-        OsgiBundleWithUrl lib = Iterables.getOnlyElement(libs);
+        assertEquals(libs.size(), 2);
+        OsgiBundleWithUrl lib = Iterables.get(libs, 1);
         Assert.assertNull(lib.getUrl());
 
         assertEquals(lib.getSymbolicName(), "org.apache.brooklyn.test.resources.osgi.brooklyn-test-osgi-entities");
@@ -803,8 +803,8 @@ public class BundleAndTypeResourcesTest extends BrooklynRestResourceTest {
         RegisteredType item = getManagementContext().getTypeRegistry().get(symbolicName, version);
         Assert.assertNotNull(item);
         Collection<OsgiBundleWithUrl> libs = item.getLibraries();
-        assertEquals(libs.size(), 1);
-        OsgiBundleWithUrl lib = Iterables.getOnlyElement(libs);
+        assertEquals(libs.size(), 2);
+        OsgiBundleWithUrl lib = Iterables.get(libs, 1);
         Assert.assertNull(lib.getUrl());
 
         // check we can find it with ResourceUtils
diff --git a/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/CatalogResourceTest.java b/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/CatalogResourceTest.java
index 9bbeb409cb..bbc7d0ff19 100644
--- a/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/CatalogResourceTest.java
+++ b/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/CatalogResourceTest.java
@@ -170,8 +170,8 @@ public class CatalogResourceTest extends BrooklynRestResourceTest {
                 .applyAsserts(() -> client());
 
         RegisteredTypeAsserts.newInstance(itemSymbolicName, TEST_VERSION)
-                .libraryNames(bundleName)
-                .libraryUrls(bundleUrl)
+                .libraryNames(new VersionedName("my.catalog.entity.id", "0.1.2"), bundleName)
+                .libraryUrls(null, bundleUrl)
                 .iconUrl("classpath:/org/apache/brooklyn/test/osgi/entities/icon.gif")
                 .applyAsserts(getManagementContext().getTypeRegistry());
     }
diff --git a/utils/rt-felix/src/test/java/org/apache/brooklyn/rt/felix/EmbeddedFelixFrameworkTest.java b/utils/rt-felix/src/test/java/org/apache/brooklyn/rt/felix/EmbeddedFelixFrameworkTest.java
index f75cf5d3f0..feb7aa2cd5 100644
--- a/utils/rt-felix/src/test/java/org/apache/brooklyn/rt/felix/EmbeddedFelixFrameworkTest.java
+++ b/utils/rt-felix/src/test/java/org/apache/brooklyn/rt/felix/EmbeddedFelixFrameworkTest.java
@@ -23,6 +23,7 @@ import java.util.List;
 import java.util.jar.JarInputStream;
 
 import org.apache.brooklyn.test.support.TestResourceUnavailableException;
+import org.apache.brooklyn.util.collections.MutableList;
 import org.apache.brooklyn.util.collections.MutableSet;
 import org.apache.brooklyn.util.io.FileUtil;
 import org.apache.brooklyn.util.os.Os;
@@ -72,14 +73,16 @@ public class EmbeddedFelixFrameworkTest {
         log.info("Bundles and exported packages:");
         MutableSet<String> allPackages = MutableSet.of();
         while (manifests.hasMoreElements()) {
-            String fullNameManifests = Streams.readFullyStringAndClose(manifests.nextElement().openStream());
+            URL mfUrl = manifests.nextElement();
+            String fullNameManifests = Streams.readFullyStringAndClose(mfUrl.openStream());
             ManifestHelper mf = null;
             try {
                 mf = ManifestHelper.forManifestContents(fullNameManifests);
                 List<String> mfPackages = mf.getExportedPackages();
-                log.info("  " + mf.getSymbolicNameVersion() + ": " + mfPackages);
+                log.info("   " + mfUrl+" / " + mf.getSymbolicNameVersion() + ": " + mfPackages);
                 allPackages.addAll(mfPackages);
             } catch (BundleException e) {
+                log.info(" x " + mfUrl+": " + e);
                 // non valid manifest
             }
         }


[brooklyn-server] 01/03: use containing bundle as part of the search path, and prefer the search path

Posted by he...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

heneveld pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/brooklyn-server.git

commit 6b9837a7680ba255ce3d9b6704bd1aa050d44393
Author: Alex Heneveld <al...@cloudsoft.io>
AuthorDate: Wed Dec 7 22:07:17 2022 +0000

    use containing bundle as part of the search path, and prefer the search path
---
 .../classloading/BrooklynClassLoadingContext.java  |   5 +
 .../catalog/NestedRefsCatalogYamlTest.java         | 148 +++++++++++++++------
 .../nested-refs-catalog-yaml-test-2.bom.yaml       |  37 ++++++
 .../nested-refs-catalog-yaml-test-3.bom.yaml       |  36 +++++
 .../catalog/internal/BasicBrooklynCatalog.java     |  66 ++++-----
 .../BrooklynClassLoadingContextSequential.java     |  21 ++-
 .../JavaBrooklynClassLoadingContext.java           |  10 +-
 .../OsgiBrooklynClassLoadingContext.java           |   2 +
 .../resolve/entity/CatalogEntitySpecResolver.java  |   4 +-
 ...BrooklynRegisteredTypeJacksonSerialization.java |   3 +-
 .../core/typereg/BasicBrooklynTypeRegistry.java    |   2 +-
 .../brooklyn/core/typereg/RegisteredTypes.java     |  23 ++++
 12 files changed, 277 insertions(+), 80 deletions(-)

diff --git a/api/src/main/java/org/apache/brooklyn/api/mgmt/classloading/BrooklynClassLoadingContext.java b/api/src/main/java/org/apache/brooklyn/api/mgmt/classloading/BrooklynClassLoadingContext.java
index 2441af550f..74fb0e33c2 100644
--- a/api/src/main/java/org/apache/brooklyn/api/mgmt/classloading/BrooklynClassLoadingContext.java
+++ b/api/src/main/java/org/apache/brooklyn/api/mgmt/classloading/BrooklynClassLoadingContext.java
@@ -19,13 +19,18 @@
 package org.apache.brooklyn.api.mgmt.classloading;
 
 import org.apache.brooklyn.api.mgmt.ManagementContext;
+import org.apache.brooklyn.api.typereg.OsgiBundleWithUrl;
 import org.apache.brooklyn.util.javalang.ClassLoadingContext;
 
+import java.util.Collection;
+
 /** 
  * As {@link ClassLoadingContext} but the {@link ManagementContext} is also available.
  */
 public interface BrooklynClassLoadingContext extends ClassLoadingContext {
 
     public ManagementContext getManagementContext();
+    // bundle search path, if defined
+    public Collection<? extends OsgiBundleWithUrl> getBundles();
 
 }
diff --git a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/NestedRefsCatalogYamlTest.java b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/NestedRefsCatalogYamlTest.java
index 7e82042241..c2f88b7e76 100644
--- a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/NestedRefsCatalogYamlTest.java
+++ b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/NestedRefsCatalogYamlTest.java
@@ -18,49 +18,20 @@
  */
 package org.apache.brooklyn.camp.brooklyn.catalog;
 
-import com.google.common.base.Joiner;
-import com.google.common.base.Throwables;
-import com.google.common.collect.Iterables;
-import org.apache.brooklyn.api.catalog.BrooklynCatalog;
-import org.apache.brooklyn.api.entity.Entity;
-import org.apache.brooklyn.api.entity.EntitySpec;
 import org.apache.brooklyn.api.internal.AbstractBrooklynObjectSpec;
-import org.apache.brooklyn.api.objs.Identifiable;
-import org.apache.brooklyn.api.typereg.BrooklynTypeRegistry;
-import org.apache.brooklyn.api.typereg.BrooklynTypeRegistry.RegisteredTypeKind;
+import org.apache.brooklyn.api.mgmt.classloading.BrooklynClassLoadingContext;
 import org.apache.brooklyn.api.typereg.RegisteredType;
 import org.apache.brooklyn.camp.brooklyn.AbstractYamlTest;
-import org.apache.brooklyn.camp.brooklyn.ConfigYamlTest;
-import org.apache.brooklyn.config.ConfigKey;
-import org.apache.brooklyn.core.catalog.internal.BasicBrooklynCatalog;
-import org.apache.brooklyn.core.catalog.internal.CatalogUtils;
-import org.apache.brooklyn.core.config.ConfigKeys;
-import org.apache.brooklyn.core.entity.Dumper;
-import org.apache.brooklyn.core.mgmt.BrooklynTags;
-import org.apache.brooklyn.core.mgmt.BrooklynTags.SpecSummary;
-import org.apache.brooklyn.core.test.entity.TestEntity;
-import org.apache.brooklyn.core.test.entity.TestEntityImpl;
-import org.apache.brooklyn.core.typereg.RegisteredTypes;
-import org.apache.brooklyn.core.workflow.WorkflowBasicTest;
-import org.apache.brooklyn.entity.stock.BasicApplication;
-import org.apache.brooklyn.entity.stock.BasicEntity;
-import org.apache.brooklyn.entity.stock.BasicEntityImpl;
+import org.apache.brooklyn.core.mgmt.classloading.OsgiBrooklynClassLoadingContext;
+import org.apache.brooklyn.core.typereg.RegisteredTypeLoadingContexts;
 import org.apache.brooklyn.test.Asserts;
-import org.apache.brooklyn.util.collections.MutableList;
-import org.apache.brooklyn.util.collections.MutableSet;
 import org.apache.brooklyn.util.core.ResourceUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.testng.Assert;
 import org.testng.annotations.Test;
 
 import java.util.Collection;
-import java.util.List;
 import java.util.Map;
-import java.util.Set;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static org.testng.Assert.*;
 
 
 public class NestedRefsCatalogYamlTest extends AbstractYamlTest {
@@ -73,23 +44,126 @@ public class NestedRefsCatalogYamlTest extends AbstractYamlTest {
     }
 
     @Test
-    public void testManyAddCatalogItems() throws Exception {
+    public void testPreferHighestVersion() {
+        addCatalogItems("brooklyn.catalog:\n" +
+                "  bundle: Bv2\n" +
+                "  version: \"2\"\n" +
+                "  items:\n" +
+                "    - id: A\n" +
+                "      item:\n" +
+                "        name: Av2\n" +
+                "        type: org.apache.brooklyn.entity.stock.BasicEntity\n");
+        addCatalogItems("brooklyn.catalog:\n" +
+                "  bundle: Bv1\n" +
+                "  version: \"1\"\n" +
+                "  items:\n" +
+                "    - id: A\n" +
+                "      item:\n" +
+                "        name: Av1\n" +
+                "        type: org.apache.brooklyn.entity.stock.BasicEntity\n");
 
-        /* test that invoke-effector doesn't cause confusion */
+        AbstractBrooklynObjectSpec<?, ?> x = mgmt().getTypeRegistry().createSpec(
+                mgmt().getTypeRegistry().get("A"), null, null);
 
-//        WorkflowBasicTest.addWorkflowStepTypes(mgmt());
+        Asserts.assertEquals(x.getDisplayName(), "Av2");
+    }
+
+    @Test
+    public void testPreferSameBundle() {
+        addCatalogItems("brooklyn.catalog:\n" +
+                "  bundle: Bv2\n" +
+                "  version: \"2\"\n" +
+                "  items:\n" +
+                "    - id: A\n" +
+                "      item:\n" +
+                "        name: Av2\n" +
+                "        type: org.apache.brooklyn.entity.stock.BasicEntity\n");
+        addCatalogItems("brooklyn.catalog:\n" +
+                "  bundle: Bv1\n" +
+                "  version: \"1\"\n" +
+                "  items:\n" +
+                "    - id: A\n" +
+                "      item:\n" +
+                "        name: Av1\n" +
+                "        type: org.apache.brooklyn.entity.stock.BasicEntity\n" +
+                "    - id: X\n" +
+                "      item:\n" +
+                "        type: A");
+        AbstractBrooklynObjectSpec<?, ?> x = mgmt().getTypeRegistry().createSpec(
+                mgmt().getTypeRegistry().get("X"), null, null);
+
+        Asserts.assertEquals(x.getDisplayName(), "Av1");
+    }
+
+    @Test
+    public void testPreferSameBundleComplex() {
+        addCatalogItems("brooklyn.catalog:\n" +
+                "  bundle: Bv2\n" +
+                "  version: \"2\"\n" +
+                "  items:\n" +
+                "    - id: A\n" +
+                "      item:\n" +
+                "        name: Av2\n" +
+                "        type: org.apache.brooklyn.entity.stock.BasicEntity\n"+
+                "    - id: Z\n" +
+                "      item:\n" +
+                "        name: Z\n" +
+                "        type: org.apache.brooklyn.entity.stock.BasicEntity\n");
+        addCatalogItems("brooklyn.catalog:\n" +
+                "  bundle: Bv1\n" +
+                "  version: \"1\"\n" +
+                "  items:\n" +
+                "    - id: A\n" +
+                "      item:\n" +
+                "        name: Av1\n" +
+                "        type: Z\n" +
+                "    - id: X\n" +
+                "      item:\n" +
+                "        type: A");
+        AbstractBrooklynObjectSpec<?, ?> x = mgmt().getTypeRegistry().createSpec(
+                mgmt().getTypeRegistry().get("X"), null, null);
+
+        Asserts.assertEquals(x.getDisplayName(), "Av1");
+    }
+
+    /* test that invoke-effector doesn't cause confusion */
+    void doTestAddAfterWorkflow(String url) {
 
+        // add invoke-effector bean via a bundle
+//        WorkflowBasicTest.addWorkflowStepTypes(mgmt());
         Collection<RegisteredType> typesW = addCatalogItems(ResourceUtils.create(this).getResourceAsString("classpath://nested-refs-catalog-yaml-workflow-test.bom.yaml"));
         Map<RegisteredType, Collection<Throwable>> resultW = mgmt().getCatalog().validateTypes(typesW);
         if (!resultW.isEmpty()) {
             Asserts.fail("Should be empty: " + resultW);
         }
 
-        Collection<RegisteredType> types = addCatalogItems(ResourceUtils.create(this).getResourceAsString("classpath://nested-refs-catalog-yaml-test.bom.yaml"));
+        // now add it as a type, in various ways
+        Collection<RegisteredType> types = addCatalogItems(ResourceUtils.create(this).getResourceAsString(url));
+
+        // should prefer from local bundle
+        Asserts.assertEquals(mgmt().getTypeRegistry().get("invoke-effector", RegisteredTypeLoadingContexts.loader(
+                new OsgiBrooklynClassLoadingContext(mgmt(), types.iterator().next().getId(), null))).getContainingBundle(), "test-bundle:0.1.0-SNAPSHOT");
+
+        // which should allow it to validate
         Map<RegisteredType, Collection<Throwable>> result = mgmt().getCatalog().validateTypes(types);
         if (!result.isEmpty()) {
-            Asserts.fail("Should be empty: " + result);
+            Asserts.fail("Failed validation should be empty: " + result);
         }
     }
 
+    @Test
+    public void testAddAmbiguousCatalogItemsPreferEntitySpecAsParent() throws Exception {
+        doTestAddAfterWorkflow("classpath://nested-refs-catalog-yaml-test.bom.yaml");
+    }
+
+    @Test
+    public void testAddAmbiguousCatalogItemsPreferFromSameBundle() throws Exception {
+        doTestAddAfterWorkflow("classpath://nested-refs-catalog-yaml-test-2.bom.yaml");
+    }
+
+    @Test(groups = "Broken")  // need to defer loading until all items pre-parsed, or correct loading later
+    public void testAddAmbiguousCatalogItemsPreferFromSameBundleEvenIfDefinedLater() throws Exception {
+        doTestAddAfterWorkflow("classpath://nested-refs-catalog-yaml-test-3.bom.yaml");
+    }
+
 }
diff --git a/camp/camp-brooklyn/src/test/resources/nested-refs-catalog-yaml-test-2.bom.yaml b/camp/camp-brooklyn/src/test/resources/nested-refs-catalog-yaml-test-2.bom.yaml
new file mode 100644
index 0000000000..1cd1c22b11
--- /dev/null
+++ b/camp/camp-brooklyn/src/test/resources/nested-refs-catalog-yaml-test-2.bom.yaml
@@ -0,0 +1,37 @@
+#
+# 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.
+#
+brooklyn.catalog:
+  bundle: test-bundle
+  version: "0.1.0-SNAPSHOT"
+  items:
+
+    - id: invoke-effector
+      item:
+        type: org.apache.brooklyn.entity.stock.BasicEntity
+
+    - id: child
+      item:
+        type: invoke-effector
+
+    - id: parent
+      item:
+        type: org.apache.brooklyn.entity.stock.BasicEntity
+        brooklyn.children:
+          - type: child
+
diff --git a/camp/camp-brooklyn/src/test/resources/nested-refs-catalog-yaml-test-3.bom.yaml b/camp/camp-brooklyn/src/test/resources/nested-refs-catalog-yaml-test-3.bom.yaml
new file mode 100644
index 0000000000..bb3b64b44f
--- /dev/null
+++ b/camp/camp-brooklyn/src/test/resources/nested-refs-catalog-yaml-test-3.bom.yaml
@@ -0,0 +1,36 @@
+#
+# 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.
+#
+brooklyn.catalog:
+  bundle: test-bundle
+  version: "0.1.0-SNAPSHOT"
+  items:
+
+    - id: child
+      item:
+        type: invoke-effector
+
+    - id: parent
+      item:
+        type: org.apache.brooklyn.entity.stock.BasicEntity
+        brooklyn.children:
+          - type: child
+
+    - id: invoke-effector
+      item:
+        type: org.apache.brooklyn.entity.stock.BasicEntity
diff --git a/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java b/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java
index 59ae974454..35f60b23ab 100644
--- a/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java
+++ b/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java
@@ -778,22 +778,8 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
             }
         }
         PlanInterpreterInferringType planInterpreter = new PlanInterpreterInferringType(id, item, sourceYaml, itemType, format,
-                (containingBundle instanceof CatalogBundle ? ((CatalogBundle)containingBundle) : null), libraryBundles,
-                null, resultLegacyFormat).resolve();
-
-        if (!planInterpreter.isResolved()) {
-            // don't throw yet, we may be able to add it in an unresolved state
-            resolutionError = Exceptions.create("Could not resolve definition of item"
-                + (Strings.isNonBlank(id) ? " '"+id+"'" : Strings.isNonBlank(symbolicName) ? " '"+symbolicName+"'" : Strings.isNonBlank(name) ? " '"+name+"'" : "")
-                // better not to show yaml, takes up lots of space, and with multiple plan transformers there might be multiple errors;
-                // some of the errors themselves may reproduce it
-                // (ideally in future we'll be able to return typed errors with caret position of error)
-//                + ":\n"+sourceYaml
-                , MutableList.<Exception>of().appendIfNotNull(resolutionError).appendAll(planInterpreter.getErrors()));
-        }
-
-        // might be null
-        itemType = planInterpreter.getCatalogItemType();
+                containingBundle, libraryBundles,
+                null, resultLegacyFormat);
 
         Map<?, ?> itemAsMap = planInterpreter.getItem();
         // the "plan yaml" includes the services: ... or brooklyn.policies: ... outer key,
@@ -925,10 +911,27 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
         final String deprecated = getFirstAs(catalogMetadata, String.class, "deprecated").orNull();
         final Boolean catalogDeprecated = Boolean.valueOf(setFromItemIfUnset(deprecated, itemAsMap, "deprecated"));
 
-        // run again now that we know the ID to catch recursive definitions and possibly other mistakes (itemType inconsistency?)
-        planInterpreter = planInterpreter.setId(id).resolve();
-        if (resolutionError==null && !planInterpreter.isResolved()) {
-            resolutionError = new IllegalStateException("Plan resolution for "+id+" breaks after id and itemType are set; is there a recursive reference or other type inconsistency?\n"+sourceYaml);
+        planInterpreter.resolve();
+        if (!planInterpreter.isResolved()) {
+            // don't throw yet, we may be able to add it in an unresolved state
+            resolutionError = Exceptions.create("Could not resolve definition of item"
+                            + (Strings.isNonBlank(id) ? " '"+id+"'" : Strings.isNonBlank(symbolicName) ? " '"+symbolicName+"'" : Strings.isNonBlank(name) ? " '"+name+"'" : "")
+                    // better not to show yaml, takes up lots of space, and with multiple plan transformers there might be multiple errors;
+                    // some of the errors themselves may reproduce it
+                    // (ideally in future we'll be able to return typed errors with caret position of error)
+//                + ":\n"+sourceYaml
+                    , MutableList.<Exception>of().appendIfNotNull(resolutionError).appendAll(planInterpreter.getErrors()));
+        }
+
+        // might be null
+        itemType = planInterpreter.getCatalogItemType();
+
+        // run again if ID has just been learned, to catch recursive definitions and possibly other mistakes (itemType inconsistency?)
+        if (!Objects.equal(id, planInterpreter.itemId)) {
+            planInterpreter.setId(id).resolve();
+            if (resolutionError == null && !planInterpreter.isResolved()) {
+                resolutionError = new IllegalStateException("Plan resolution for " + id + " breaks after id and itemType are set; is there a recursive reference or other type inconsistency?\n" + sourceYaml);
+            }
         }
         if (throwOnError && resolutionError!=null) {
             // if there was an error, throw it here
@@ -993,14 +996,14 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
                 // which normally has "type: " prefixed
                 sourcePlanYaml = planInterpreter.itemYaml;
             }
-            
 
+            Set<OsgiBundleWithUrl> searchBundles = MutableSet.<OsgiBundleWithUrl>of().putIfNotNull(containingBundle).putAll(libraryBundles);
             BasicRegisteredType type = createYetUnsavedRegisteredTypeInstance(
                     BrooklynObjectType.of(planInterpreter.catalogItemType).getSpecType()!=null ? RegisteredTypeKind.SPEC
                             : planInterpreter.catalogItemType==CatalogItemType.BEAN ? RegisteredTypeKind.BEAN
                             : RegisteredTypeKind.UNRESOLVED,
                     symbolicName, version,
-                    containingBundle, libraryBundles, 
+                    containingBundle, searchBundles,
                     displayName, description, catalogIconUrl, catalogDeprecated, sourcePlanYaml, 
                     tags, aliases, catalogDisabled, superTypes, format);
 
@@ -1036,7 +1039,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
     private BasicRegisteredType createYetUnsavedRegisteredTypeInstance(
             RegisteredTypeKind kind,
             String symbolicName, String version,
-            ManagedBundle containingBundle, Collection<CatalogBundle> libraryBundles,
+            ManagedBundle containingBundle, Collection<OsgiBundleWithUrl> libraryBundles,
             String displayName, String description,
             String catalogIconUrl, final Boolean catalogDeprecated, String sourcePlanYaml, Set<Object> tags, List<String> aliases,
             Boolean catalogDisabled, MutableList<Object> superTypes, String format) {
@@ -1294,7 +1297,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
         final Map<?,?> item;
         final String itemYaml;
         final String format;
-        final CatalogBundle containingBundle;
+        final OsgiBundleWithUrl containingBundle;
         final Collection<CatalogBundle> libraryBundles;
         final List<CatalogItemDtoAbstract<?, ?>> itemsDefinedSoFar;
         RegisteredTypeLoadingContext constraint;
@@ -1307,7 +1310,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
         List<Exception> transformerErrors = MutableList.of();
 
         public PlanInterpreterInferringType(@Nullable String itemId, Object itemDefinitionParsedToStringOrMap, String itemYaml, @Nullable CatalogItemType optionalCiType, @Nullable String format,
-                                            CatalogBundle containingBundle, Collection<CatalogBundle> libraryBundles,
+                                            OsgiBundleWithUrl containingBundle, Collection<CatalogBundle> libraryBundles,
                                             RegisteredTypeLoadingContext constraint, List<CatalogItemDtoAbstract<?,?>> itemsDefinedSoFar) {
             // ID is useful to prevent recursive references (possibly only supported for entities?)
             this.itemId = itemId;
@@ -1348,7 +1351,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
             this.itemsDefinedSoFar = itemsDefinedSoFar;
         }
 
-        public PlanInterpreterInferringType resolve() {
+        public void resolve() {
             try {
                 currentlyResolvingType.set(Strings.isBlank(itemId) ? itemYaml : itemId);
 
@@ -1367,7 +1370,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
                         resolved = false;
                         attemptLegacySpecTransformersForVariousSpecTypes();
                     }
-                    return this;
+                    return;
                 }
 
                 // for now, these are the lowest-priority errors (reported after the others)
@@ -1382,7 +1385,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
                         planYaml = itemYaml;
                         resolved = true;
                     }
-                    return this;
+                    return;
                 }
 
                 // couldn't resolve it with the plan transformers; retry with legacy "spec" transformers.
@@ -1393,7 +1396,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
                     attemptLegacySpecTransformersForVariousSpecTypes();
                 }
 
-                return this;
+                return;
             } finally {
                 currentlyResolvingType.remove();
             }
@@ -1427,8 +1430,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
             try {
                 suspicionOfABean = false;
 
-                Set<? extends OsgiBundleWithUrl> searchBundles = MutableSet.copyOf(libraryBundles)
-                        .putIfNotNull(containingBundle);
+                Set<OsgiBundleWithUrl> searchBundles = MutableSet.<OsgiBundleWithUrl>of().putIfNotNull(containingBundle).putAll(libraryBundles);
                 BrooklynClassLoadingContext loader = new OsgiBrooklynClassLoadingContext(mgmt, null, searchBundles);
                 if (catalogItemType == null) {
                     // attempt to detect whether it is a bean
@@ -1988,7 +1990,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
             // try spec instantiation if we know the BO Type (no point otherwise)
             resultT = RegisteredTypes.copyResolved(RegisteredTypeKind.SPEC, typeToValidate);
             try {
-                resultO = ((BasicBrooklynTypeRegistry)mgmt.getTypeRegistry()).createSpec(resultT, constraint, boType.getSpecType());
+                resultO = mgmt.getTypeRegistry().createSpec(resultT, constraint, boType.getSpecType());
             } catch (Exception e) {
                 Exceptions.propagateIfFatal(e);
                 specError = e;
diff --git a/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/BrooklynClassLoadingContextSequential.java b/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/BrooklynClassLoadingContextSequential.java
index ddd5c5b364..8e7d29a3a8 100644
--- a/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/BrooklynClassLoadingContextSequential.java
+++ b/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/BrooklynClassLoadingContextSequential.java
@@ -18,12 +18,10 @@
  */
 package org.apache.brooklyn.core.mgmt.classloading;
 
-import java.net.URL;
-import java.util.List;
-import java.util.Set;
-
+import com.google.common.base.Objects;
 import org.apache.brooklyn.api.mgmt.ManagementContext;
 import org.apache.brooklyn.api.mgmt.classloading.BrooklynClassLoadingContext;
+import org.apache.brooklyn.api.typereg.OsgiBundleWithUrl;
 import org.apache.brooklyn.util.collections.MutableList;
 import org.apache.brooklyn.util.collections.MutableSet;
 import org.apache.brooklyn.util.exceptions.Exceptions;
@@ -31,7 +29,10 @@ import org.apache.brooklyn.util.guava.Maybe;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.google.common.base.Objects;
+import java.net.URL;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
 
 public final class BrooklynClassLoadingContextSequential extends AbstractBrooklynClassLoadingContext {
 
@@ -46,7 +47,15 @@ public final class BrooklynClassLoadingContextSequential extends AbstractBrookly
         for (BrooklynClassLoadingContext target: targets)
             add(target);
     }
-    
+
+    @Override
+    public Collection<? extends OsgiBundleWithUrl> getBundles() {
+        MutableSet<OsgiBundleWithUrl> result = MutableSet.of();
+        primaries.forEach(c -> result.addAll(c.getBundles()));
+        secondaries.forEach(c -> result.addAll(c.getBundles()));
+        return result;
+    }
+
     public void add(BrooklynClassLoadingContext target) {
         if (target instanceof BrooklynClassLoadingContextSequential) {
             for (BrooklynClassLoadingContext targetN: ((BrooklynClassLoadingContextSequential)target).primaries )
diff --git a/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/JavaBrooklynClassLoadingContext.java b/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/JavaBrooklynClassLoadingContext.java
index 17c1573c15..1e82705681 100644
--- a/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/JavaBrooklynClassLoadingContext.java
+++ b/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/JavaBrooklynClassLoadingContext.java
@@ -22,8 +22,11 @@ import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
 
 import java.net.URL;
+import java.util.Collection;
+import java.util.Collections;
 
 import org.apache.brooklyn.api.mgmt.ManagementContext;
+import org.apache.brooklyn.api.typereg.OsgiBundleWithUrl;
 import org.apache.brooklyn.core.mgmt.persist.DeserializingClassRenamesProvider;
 import org.apache.brooklyn.util.core.ClassLoaderUtils;
 import org.apache.brooklyn.util.exceptions.Exceptions;
@@ -48,7 +51,12 @@ public class JavaBrooklynClassLoadingContext extends AbstractBrooklynClassLoadin
     public static JavaBrooklynClassLoadingContext create(ClassLoader loader) {
         return new JavaBrooklynClassLoadingContext(null, checkNotNull(loader, "loader"));
     }
-    
+
+    @Override
+    public Collection<? extends OsgiBundleWithUrl> getBundles() {
+        return Collections.emptySet();
+    }
+
     /**
      * At least one of mgmt or loader must not be null.
      * @deprecated since 0.7.0 only for legacy catalog items which provide a non-osgi loader; see {@link #newDefault(ManagementContext)}
diff --git a/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/OsgiBrooklynClassLoadingContext.java b/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/OsgiBrooklynClassLoadingContext.java
index c410f9e511..46a83e58bf 100644
--- a/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/OsgiBrooklynClassLoadingContext.java
+++ b/core/src/main/java/org/apache/brooklyn/core/mgmt/classloading/OsgiBrooklynClassLoadingContext.java
@@ -30,9 +30,11 @@ import org.apache.brooklyn.core.entity.EntityInternal;
 import org.apache.brooklyn.core.mgmt.entitlement.Entitlements;
 import org.apache.brooklyn.core.mgmt.ha.OsgiManager;
 import org.apache.brooklyn.core.mgmt.internal.ManagementContextInternal;
+import org.apache.brooklyn.util.collections.MutableList;
 import org.apache.brooklyn.util.guava.Maybe;
 
 import com.google.common.base.Objects;
+import org.apache.brooklyn.util.osgi.VersionedName;
 
 public class OsgiBrooklynClassLoadingContext extends AbstractBrooklynClassLoadingContext {
 
diff --git a/core/src/main/java/org/apache/brooklyn/core/resolve/entity/CatalogEntitySpecResolver.java b/core/src/main/java/org/apache/brooklyn/core/resolve/entity/CatalogEntitySpecResolver.java
index e04be5fb4d..8cff6a1899 100644
--- a/core/src/main/java/org/apache/brooklyn/core/resolve/entity/CatalogEntitySpecResolver.java
+++ b/core/src/main/java/org/apache/brooklyn/core/resolve/entity/CatalogEntitySpecResolver.java
@@ -62,7 +62,7 @@ public class CatalogEntitySpecResolver extends AbstractEntitySpecResolver {
     @Override
     protected boolean canResolve(String type, BrooklynClassLoadingContext loader) {
         String localType = getLocalType(type);
-        RegisteredType item = mgmt.getTypeRegistry().get(localType);
+        RegisteredType item = mgmt.getTypeRegistry().get(localType, RegisteredTypeLoadingContexts.loader(loader));
         if (item==null) {
             item = loadUpgrade(localType);
         }
@@ -78,7 +78,7 @@ public class CatalogEntitySpecResolver extends AbstractEntitySpecResolver {
     @Override
     public EntitySpec<?> resolve(String type, BrooklynClassLoadingContext loader, Set<String> parentEncounteredTypes) {
         String localType = getLocalType(type);
-        RegisteredType item = mgmt.getTypeRegistry().get(localType, RegisteredTypeLoadingContexts.spec(Entity.class));
+        RegisteredType item = mgmt.getTypeRegistry().get(localType, RegisteredTypeLoadingContexts.withLoader(RegisteredTypeLoadingContexts.spec(Entity.class), loader));
         boolean upgradeRequired = item==null;
         
         if (upgradeRequired) {
diff --git a/core/src/main/java/org/apache/brooklyn/core/resolve/jackson/BrooklynRegisteredTypeJacksonSerialization.java b/core/src/main/java/org/apache/brooklyn/core/resolve/jackson/BrooklynRegisteredTypeJacksonSerialization.java
index 5bd425a57c..31e0cab4c7 100644
--- a/core/src/main/java/org/apache/brooklyn/core/resolve/jackson/BrooklynRegisteredTypeJacksonSerialization.java
+++ b/core/src/main/java/org/apache/brooklyn/core/resolve/jackson/BrooklynRegisteredTypeJacksonSerialization.java
@@ -45,6 +45,7 @@ import org.apache.brooklyn.core.mgmt.internal.LocalManagementContext;
 import org.apache.brooklyn.core.resolve.jackson.AsPropertyIfAmbiguous.AsPropertyButNotIfFieldConflictTypeDeserializer;
 import org.apache.brooklyn.core.resolve.jackson.AsPropertyIfAmbiguous.AsPropertyIfAmbiguousTypeSerializer;
 import org.apache.brooklyn.core.resolve.jackson.AsPropertyIfAmbiguous.HasBaseType;
+import org.apache.brooklyn.core.typereg.RegisteredTypeLoadingContexts;
 import org.apache.brooklyn.util.core.flags.BrooklynTypeNameResolution;
 import org.apache.brooklyn.util.exceptions.Exceptions;
 
@@ -124,7 +125,7 @@ public class BrooklynRegisteredTypeJacksonSerialization {
             }
 
             if (allowRegisteredTypes && mgmt!=null) {
-                RegisteredType rt = mgmt.getTypeRegistry().get(id);
+                RegisteredType rt = mgmt.getTypeRegistry().get(id, RegisteredTypeLoadingContexts.loader(loader));
                 if (rt != null) {
                     return new BrooklynJacksonType(rt);
                 }
diff --git a/core/src/main/java/org/apache/brooklyn/core/typereg/BasicBrooklynTypeRegistry.java b/core/src/main/java/org/apache/brooklyn/core/typereg/BasicBrooklynTypeRegistry.java
index 766841775a..2cefe89a98 100644
--- a/core/src/main/java/org/apache/brooklyn/core/typereg/BasicBrooklynTypeRegistry.java
+++ b/core/src/main/java/org/apache/brooklyn/core/typereg/BasicBrooklynTypeRegistry.java
@@ -207,7 +207,7 @@ public class BasicBrooklynTypeRegistry implements BrooklynTypeRegistry {
         }
         
         if (!Iterables.isEmpty(types)) {
-            RegisteredType type = RegisteredTypes.getBestVersion(types);
+            RegisteredType type = RegisteredTypes.getBestVersionInContext(types, context);
             if (type!=null) return Maybe.of(type);
         }
         
diff --git a/core/src/main/java/org/apache/brooklyn/core/typereg/RegisteredTypes.java b/core/src/main/java/org/apache/brooklyn/core/typereg/RegisteredTypes.java
index f8fec6e810..5a416b84c1 100644
--- a/core/src/main/java/org/apache/brooklyn/core/typereg/RegisteredTypes.java
+++ b/core/src/main/java/org/apache/brooklyn/core/typereg/RegisteredTypes.java
@@ -52,6 +52,7 @@ import org.apache.brooklyn.core.mgmt.BrooklynTags;
 import org.apache.brooklyn.core.mgmt.BrooklynTags.NamedStringTag;
 import org.apache.brooklyn.core.mgmt.BrooklynTaskTags;
 import org.apache.brooklyn.core.mgmt.classloading.JavaBrooklynClassLoadingContext;
+import org.apache.brooklyn.core.mgmt.classloading.OsgiBrooklynClassLoadingContext;
 import org.apache.brooklyn.core.objs.BrooklynObjectInternal;
 import org.apache.brooklyn.core.typereg.JavaClassNameTypePlanTransformer.JavaClassNameTypeImplementationPlan;
 import org.apache.brooklyn.util.collections.Jsonya;
@@ -59,6 +60,7 @@ import org.apache.brooklyn.util.core.task.Tasks;
 import org.apache.brooklyn.util.exceptions.Exceptions;
 import org.apache.brooklyn.util.guava.Maybe;
 import org.apache.brooklyn.util.guava.Maybe.Absent;
+import org.apache.brooklyn.util.osgi.VersionedName;
 import org.apache.brooklyn.util.stream.Streams;
 import org.apache.brooklyn.util.text.NaturalOrderComparator;
 import org.apache.brooklyn.util.text.Strings;
@@ -518,6 +520,27 @@ public class RegisteredTypes {
         if (types==null || !types.iterator().hasNext()) return null;
         return Ordering.from(RegisteredTypeNameThenBestFirstComparator.INSTANCE).min(types);
     }
+
+    public static RegisteredType getBestVersionInContext(Iterable<RegisteredType> types, RegisteredTypeLoadingContext context) {
+        if (types==null) return null;
+        Iterator<RegisteredType> ti = types.iterator();
+        if (!ti.hasNext()) return null;
+        RegisteredType first = ti.next();
+        if (!ti.hasNext()) return first;  //only
+
+        Collection<? extends OsgiBundleWithUrl> preferredBundles = context.getLoader().getBundles();
+        for (OsgiBundleWithUrl b: preferredBundles) {
+            Iterable<RegisteredType> typesInBundle = Iterables.filter(types, t -> Objects.equal(
+                    VersionedName.fromString(t.getContainingBundle()), b.getVersionedName()));
+            if (typesInBundle.iterator().hasNext()) {
+                if (log.isTraceEnabled()) log.trace("Preferring "+typesInBundle+" from "+types+" because its bundle is in the explicit loader list");
+                types = typesInBundle;
+                break;
+            }
+        }
+
+        return getBestVersion(types);
+    }
     
     /** by name, then with disabled, deprecated first, then by increasing version */ 
     public static class RegisteredTypeNameThenWorstFirstComparator implements Comparator<RegisteredType> {


[brooklyn-server] 02/03: allow kind to change during validation

Posted by he...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

heneveld pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/brooklyn-server.git

commit 2f429a1c0d55482f9ccbc70302bf70dfc04c3d15
Author: Alex Heneveld <al...@cloudsoft.io>
AuthorDate: Wed Dec 7 22:56:46 2022 +0000

    allow kind to change during validation
    
    make the last failing test pass
---
 .../catalog/NestedRefsCatalogYamlTest.java         |  9 ++----
 .../catalog/internal/BasicBrooklynCatalog.java     | 32 ++++++++++++++--------
 .../brooklyn/core/typereg/RegisteredTypes.java     | 24 ++++++++++------
 3 files changed, 38 insertions(+), 27 deletions(-)

diff --git a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/NestedRefsCatalogYamlTest.java b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/NestedRefsCatalogYamlTest.java
index c2f88b7e76..6bbcb140c5 100644
--- a/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/NestedRefsCatalogYamlTest.java
+++ b/camp/camp-brooklyn/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/NestedRefsCatalogYamlTest.java
@@ -128,14 +128,9 @@ public class NestedRefsCatalogYamlTest extends AbstractYamlTest {
 
     /* test that invoke-effector doesn't cause confusion */
     void doTestAddAfterWorkflow(String url) {
-
         // add invoke-effector bean via a bundle
 //        WorkflowBasicTest.addWorkflowStepTypes(mgmt());
         Collection<RegisteredType> typesW = addCatalogItems(ResourceUtils.create(this).getResourceAsString("classpath://nested-refs-catalog-yaml-workflow-test.bom.yaml"));
-        Map<RegisteredType, Collection<Throwable>> resultW = mgmt().getCatalog().validateTypes(typesW);
-        if (!resultW.isEmpty()) {
-            Asserts.fail("Should be empty: " + resultW);
-        }
 
         // now add it as a type, in various ways
         Collection<RegisteredType> types = addCatalogItems(ResourceUtils.create(this).getResourceAsString(url));
@@ -144,7 +139,7 @@ public class NestedRefsCatalogYamlTest extends AbstractYamlTest {
         Asserts.assertEquals(mgmt().getTypeRegistry().get("invoke-effector", RegisteredTypeLoadingContexts.loader(
                 new OsgiBrooklynClassLoadingContext(mgmt(), types.iterator().next().getId(), null))).getContainingBundle(), "test-bundle:0.1.0-SNAPSHOT");
 
-        // which should allow it to validate
+        // re-do the validation to be sure
         Map<RegisteredType, Collection<Throwable>> result = mgmt().getCatalog().validateTypes(types);
         if (!result.isEmpty()) {
             Asserts.fail("Failed validation should be empty: " + result);
@@ -161,7 +156,7 @@ public class NestedRefsCatalogYamlTest extends AbstractYamlTest {
         doTestAddAfterWorkflow("classpath://nested-refs-catalog-yaml-test-2.bom.yaml");
     }
 
-    @Test(groups = "Broken")  // need to defer loading until all items pre-parsed, or correct loading later
+    @Test  // allow validation to change the kind once all peers are loaded
     public void testAddAmbiguousCatalogItemsPreferFromSameBundleEvenIfDefinedLater() throws Exception {
         doTestAddAfterWorkflow("classpath://nested-refs-catalog-yaml-test-3.bom.yaml");
     }
diff --git a/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java b/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java
index 35f60b23ab..fdfb87b253 100644
--- a/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java
+++ b/core/src/main/java/org/apache/brooklyn/core/catalog/internal/BasicBrooklynCatalog.java
@@ -65,6 +65,7 @@ import org.apache.brooklyn.core.typereg.*;
 import org.apache.brooklyn.util.collections.MutableList;
 import org.apache.brooklyn.util.collections.MutableMap;
 import org.apache.brooklyn.util.collections.MutableSet;
+import org.apache.brooklyn.util.core.ClassLoaderUtils;
 import org.apache.brooklyn.util.core.ResourceUtils;
 import org.apache.brooklyn.util.core.flags.BrooklynTypeNameResolution.BrooklynTypeNameResolver;
 import org.apache.brooklyn.util.core.flags.TypeCoercions;
@@ -911,6 +912,8 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
         final String deprecated = getFirstAs(catalogMetadata, String.class, "deprecated").orNull();
         final Boolean catalogDeprecated = Boolean.valueOf(setFromItemIfUnset(deprecated, itemAsMap, "deprecated"));
 
+        // provisional resolution - will be done again during validation, and even the kind might change, eg if there is a local bundle item
+        // indicating a different preferred supertype as compared with something else stored in type registry
         planInterpreter.resolve();
         if (!planInterpreter.isResolved()) {
             // don't throw yet, we may be able to add it in an unresolved state
@@ -1908,7 +1911,9 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
                 }
                 Collection<Throwable> tr = validateType(t, null, true);
                 if (!tr.isEmpty()) {
-                    result.put(t, tr);
+                    // reload it in case it changed
+                    result.put(mgmt.getTypeRegistry().get(t.getId(), RegisteredTypeLoadingContexts.loader(CatalogUtils.newClassLoadingContext(mgmt, t))),
+                            tr);
                 }
             }
             String msg = (typesRemainingToValidate.size()-result.size())+" validated, "+result.size()+" unvalidated";
@@ -1928,7 +1933,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
     public Collection<Throwable> validateType(RegisteredType typeToValidate, RegisteredTypeLoadingContext constraint, boolean allowUnresolved) {
         try {
             currentlyValidatingType.set(typeToValidate);
-            ReferenceWithError<RegisteredType> result = validateResolve(typeToValidate, constraint);
+            ReferenceWithError<RegisteredType> result = validateResolve(typeToValidate, constraint, true);
             if (result.hasError()) {
                 if (allowUnresolved && RegisteredTypes.isTemplate(typeToValidate)) {
                     // ignore for templates
@@ -1952,7 +1957,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
      * The argument may be changed (e.g. its kind set, supertypes set), and normal usage is to add 
      * a type in an "unresolved" state if things may need to reference it, then call resolve here,
      * then replace what was added with the argument given here. */
-    ReferenceWithError<RegisteredType> validateResolve(RegisteredType typeToValidate, RegisteredTypeLoadingContext constraint) {
+    ReferenceWithError<RegisteredType> validateResolve(RegisteredType typeToValidate, RegisteredTypeLoadingContext constraint, boolean allowChangingKind) {
         Throwable inconsistentSuperTypesError=null, specError=null, beanError=null;
         List<Throwable> guesserErrors = MutableList.of();
         
@@ -1988,7 +1993,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
         Object resultO = null;
         if (resultO==null && boType!=null) try {
             // try spec instantiation if we know the BO Type (no point otherwise)
-            resultT = RegisteredTypes.copyResolved(RegisteredTypeKind.SPEC, typeToValidate);
+            resultT = RegisteredTypes.copyResolved(RegisteredTypeKind.SPEC, typeToValidate, allowChangingKind);
             try {
                 resultO = mgmt.getTypeRegistry().createSpec(resultT, constraint, boType.getSpecType());
             } catch (Exception e) {
@@ -2003,7 +2008,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
         
         if (resultO==null) try {
             // try it as a bean
-            resultT = RegisteredTypes.copyResolved(RegisteredTypeKind.BEAN, typeToValidate);
+            resultT = RegisteredTypes.copyResolved(RegisteredTypeKind.BEAN, typeToValidate, allowChangingKind);
             try {
                 resultO = ((BasicBrooklynTypeRegistry)mgmt.getTypeRegistry()).createBean(resultT, constraint, superJ);
                 if (typeToValidate.getKind()!=RegisteredTypeKind.BEAN && isDubiousBeanType(resultO)) {
@@ -2031,10 +2036,15 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
             log.trace("Validating {}: \n{}", typeToValidate, yaml);
             
             CatalogBundle bundle = typeToValidate.getContainingBundle() != null ? CatalogItemDtoAbstract.parseLibraries(Arrays.asList(typeToValidate.getContainingBundle())).iterator().next() : null;
-            CatalogItemType itemType = boType!=null ? CatalogItemType.ofTargetClass(boType.getInterfaceType()) : null;
-            if (itemType==null && typeToValidate.getKind() == RegisteredTypeKind.BEAN) {
-                itemType = CatalogItemType.BEAN;
+            CatalogItemType itemType = null;
+
+            if (!allowChangingKind) {
+                itemType = boType!=null ? CatalogItemType.ofTargetClass(boType.getInterfaceType()) : null;
+                if (itemType==null && typeToValidate.getKind() == RegisteredTypeKind.BEAN) {
+                    itemType = CatalogItemType.BEAN;
+                }
             }
+
             String format = typeToValidate.getPlan().getPlanFormat();
             PlanInterpreterInferringType guesser = new PlanInterpreterInferringType(typeToValidate.getSymbolicName(), Iterables.getOnlyElement( Yamls.parseAll(yaml) ),
                 yaml, itemType, format, bundle, CatalogItemDtoAbstract.parseLibraries( typeToValidate.getLibraries() ), constraint, null);
@@ -2059,7 +2069,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
                         supers = MutableSet.copyOf(supers);
                         supers.add(boType.getInterfaceType());
                         // didn't know type before, retry now that we know the type
-                        resultT = RegisteredTypes.copyResolved(RegisteredTypeKind.SPEC, resultT);
+                        resultT = RegisteredTypes.copyResolved(RegisteredTypeKind.SPEC, resultT, allowChangingKind);
                         RegisteredTypes.addSuperTypes(resultT, supers);
                         changedSomething = true;
                     }
@@ -2074,7 +2084,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
                 if (changedSomething) {
                     log.debug("Re-resolving "+resultT+" following detection of change");
                     // try again with new plan or supertype info
-                    return validateResolve(resultT, constraint);
+                    return validateResolve(resultT, constraint, false);
                     
                 } else if (Objects.equal(boType, BrooklynObjectType.of(ciType))) {
                     if (specError==null) {
@@ -2099,7 +2109,7 @@ public class BasicBrooklynCatalog implements BrooklynCatalog {
             if (resultO instanceof BrooklynObject) {
                 // if it was a bean that points at a BO then switch it to a spec and try to re-validate
                 log.debug("Re-resolving "+resultT+" following detection of bean where spec was expected");
-                return validateResolve(RegisteredTypes.copyResolved(RegisteredTypeKind.SPEC, typeToValidate), constraint);
+                return validateResolve(RegisteredTypes.copyResolved(RegisteredTypeKind.SPEC, typeToValidate), constraint, false);
             }
             Class<?> resultS;
             if (resultT.getKind() == RegisteredTypeKind.SPEC) {
diff --git a/core/src/main/java/org/apache/brooklyn/core/typereg/RegisteredTypes.java b/core/src/main/java/org/apache/brooklyn/core/typereg/RegisteredTypes.java
index 5a416b84c1..ec88e89ae6 100644
--- a/core/src/main/java/org/apache/brooklyn/core/typereg/RegisteredTypes.java
+++ b/core/src/main/java/org/apache/brooklyn/core/typereg/RegisteredTypes.java
@@ -237,7 +237,10 @@ public class RegisteredTypes {
     }
     @Beta
     public static RegisteredType copyResolved(RegisteredTypeKind kind, RegisteredType t) {
-        if (t.getKind()!=null && t.getKind()!=RegisteredTypeKind.UNRESOLVED && t.getKind()!=kind) {
+        return copyResolved(kind, t, false);
+    }
+    public static RegisteredType copyResolved(RegisteredTypeKind kind, RegisteredType t, boolean allowChangingKind) {
+        if (!allowChangingKind && t.getKind()!=null && t.getKind()!=RegisteredTypeKind.UNRESOLVED && t.getKind()!=kind) {
             throw new IllegalStateException("Cannot copy resolve "+t+" ("+t.getKind()+") as "+kind);
         }
         return newInstance(kind, t.getSymbolicName(), t.getVersion(), t.getPlan(), 
@@ -528,14 +531,17 @@ public class RegisteredTypes {
         RegisteredType first = ti.next();
         if (!ti.hasNext()) return first;  //only
 
-        Collection<? extends OsgiBundleWithUrl> preferredBundles = context.getLoader().getBundles();
-        for (OsgiBundleWithUrl b: preferredBundles) {
-            Iterable<RegisteredType> typesInBundle = Iterables.filter(types, t -> Objects.equal(
-                    VersionedName.fromString(t.getContainingBundle()), b.getVersionedName()));
-            if (typesInBundle.iterator().hasNext()) {
-                if (log.isTraceEnabled()) log.trace("Preferring "+typesInBundle+" from "+types+" because its bundle is in the explicit loader list");
-                types = typesInBundle;
-                break;
+        if (context!=null && context.getLoader()!=null) {
+            Collection<? extends OsgiBundleWithUrl> preferredBundles = context.getLoader().getBundles();
+            for (OsgiBundleWithUrl b : preferredBundles) {
+                Iterable<RegisteredType> typesInBundle = Iterables.filter(types, t -> t.getContainingBundle() != null && Objects.equal(
+                        VersionedName.fromString(t.getContainingBundle()).toOsgiString(), b.getVersionedName().toOsgiString()));
+                if (typesInBundle.iterator().hasNext()) {
+                    if (log.isTraceEnabled())
+                        log.trace("Preferring " + typesInBundle + " from " + types + " because its bundle is in the explicit loader list");
+                    types = typesInBundle;
+                    break;
+                }
             }
         }