Return-Path: X-Original-To: apmail-brooklyn-commits-archive@minotaur.apache.org Delivered-To: apmail-brooklyn-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 9577818E14 for ; Wed, 5 Aug 2015 20:56:21 +0000 (UTC) Received: (qmail 71160 invoked by uid 500); 5 Aug 2015 20:56:21 -0000 Delivered-To: apmail-brooklyn-commits-archive@brooklyn.apache.org Received: (qmail 71136 invoked by uid 500); 5 Aug 2015 20:56:21 -0000 Mailing-List: contact commits-help@brooklyn.incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@brooklyn.incubator.apache.org Delivered-To: mailing list commits@brooklyn.incubator.apache.org Received: (qmail 71121 invoked by uid 99); 5 Aug 2015 20:56:21 -0000 Received: from Unknown (HELO spamd1-us-west.apache.org) (209.188.14.142) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 05 Aug 2015 20:56:21 +0000 Received: from localhost (localhost [127.0.0.1]) by spamd1-us-west.apache.org (ASF Mail Server at spamd1-us-west.apache.org) with ESMTP id DE851DAB6D for ; Wed, 5 Aug 2015 20:56:20 +0000 (UTC) X-Virus-Scanned: Debian amavisd-new at spamd1-us-west.apache.org X-Spam-Flag: NO X-Spam-Score: 1.678 X-Spam-Level: * X-Spam-Status: No, score=1.678 tagged_above=-999 required=6.31 tests=[KAM_ASCII_DIVIDERS=0.8, KAM_LAZY_DOMAIN_SECURITY=1, RCVD_IN_MSPIKE_H3=-0.01, RCVD_IN_MSPIKE_WL=-0.01, RP_MATCHES_RCVD=-0.102] autolearn=disabled Received: from mx1-us-west.apache.org ([10.40.0.8]) by localhost (spamd1-us-west.apache.org [10.40.0.7]) (amavisd-new, port 10024) with ESMTP id 4n8rhDQPQ26d for ; Wed, 5 Aug 2015 20:56:14 +0000 (UTC) Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by mx1-us-west.apache.org (ASF Mail Server at mx1-us-west.apache.org) with SMTP id 5583E260BF for ; Wed, 5 Aug 2015 20:56:06 +0000 (UTC) Received: (qmail 69525 invoked by uid 99); 5 Aug 2015 20:56:06 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 05 Aug 2015 20:56:06 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id B4309E6813; Wed, 5 Aug 2015 20:56:05 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: hadrian@apache.org To: commits@brooklyn.incubator.apache.org Date: Wed, 05 Aug 2015 20:56:12 -0000 Message-Id: <7c89d02b36fc478fa268c3fdea8399e2@git.apache.org> In-Reply-To: References: X-Mailer: ASF-Git Admin Mailer Subject: [08/20] incubator-brooklyn git commit: Package rename to org.apache.brooklyn: usage/camp/ http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/LocationsYamlTest.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/LocationsYamlTest.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/LocationsYamlTest.java new file mode 100644 index 0000000..6f79471 --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/LocationsYamlTest.java @@ -0,0 +1,285 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertNotNull; +import static org.testng.Assert.assertTrue; + +import java.io.StringReader; +import java.util.List; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.testng.Assert; +import org.testng.annotations.Test; + +import brooklyn.entity.Entity; +import brooklyn.location.Location; +import brooklyn.location.MachineLocation; +import brooklyn.location.basic.FixedListMachineProvisioningLocation; +import brooklyn.location.basic.LocalhostMachineProvisioningLocation; +import brooklyn.location.basic.MultiLocation; +import brooklyn.location.basic.SshMachineLocation; +import brooklyn.util.text.Strings; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Iterables; + +public class LocationsYamlTest extends AbstractYamlTest { + private static final Logger log = LoggerFactory.getLogger(LocationsYamlTest.class); + + @Test + public void testLocationString() throws Exception { + String yaml = + "location: localhost\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + LocalhostMachineProvisioningLocation loc = (LocalhostMachineProvisioningLocation) Iterables.getOnlyElement(app.getLocations()); + assertNotNull(loc); + } + + @Test + public void testLocationComplexString() throws Exception { + String yaml = + "location: localhost:(name=myname)\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + LocalhostMachineProvisioningLocation loc = (LocalhostMachineProvisioningLocation) Iterables.getOnlyElement(app.getLocations()); + assertEquals(loc.getDisplayName(), "myname"); + } + + @Test + public void testLocationSplitLineWithNoConfig() throws Exception { + String yaml = + "location:\n"+ + " localhost\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + LocalhostMachineProvisioningLocation loc = (LocalhostMachineProvisioningLocation) Iterables.getOnlyElement(app.getLocations()); + assertNotNull(loc); + } + + @Test + public void testMultiLocations() throws Exception { + String yaml = + "locations:\n"+ + "- localhost:(name=loc1)\n"+ + "- localhost:(name=loc2)\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + List locs = ImmutableList.copyOf(app.getLocations()); + assertEquals(locs.size(), 2, "locs="+locs); + LocalhostMachineProvisioningLocation loc1 = (LocalhostMachineProvisioningLocation) locs.get(0); + LocalhostMachineProvisioningLocation loc2 = (LocalhostMachineProvisioningLocation) locs.get(1); + assertEquals(loc1.getDisplayName(), "loc1"); + assertEquals(loc2.getDisplayName(), "loc2"); + } + + @Test + public void testLocationConfig() throws Exception { + String yaml = + "location:\n"+ + " localhost:\n"+ + " displayName: myname\n"+ + " myconfkey: myconfval\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + LocalhostMachineProvisioningLocation loc = (LocalhostMachineProvisioningLocation) Iterables.getOnlyElement(app.getLocations()); + assertEquals(loc.getDisplayName(), "myname"); + assertEquals(loc.config().getLocalBag().getStringKey("myconfkey"), "myconfval"); + } + + @Test + public void testMultiLocationConfig() throws Exception { + String yaml = + "locations:\n"+ + "- localhost:\n"+ + " displayName: myname1\n"+ + " myconfkey: myconfval1\n"+ + "- localhost:\n"+ + " displayName: myname2\n"+ + " myconfkey: myconfval2\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + List locs = ImmutableList.copyOf(app.getLocations()); + assertEquals(locs.size(), 2, "locs="+locs); + LocalhostMachineProvisioningLocation loc1 = (LocalhostMachineProvisioningLocation) locs.get(0); + LocalhostMachineProvisioningLocation loc2 = (LocalhostMachineProvisioningLocation) locs.get(1); + assertEquals(loc1.getDisplayName(), "myname1"); + assertEquals(loc1.config().getLocalBag().getStringKey("myconfkey"), "myconfval1"); + assertEquals(loc2.getDisplayName(), "myname2"); + assertEquals(loc2.config().getLocalBag().getStringKey("myconfkey"), "myconfval2"); + } + + // TODO Fails because PlanInterpretationContext constructor throws NPE on location's value (using ImmutableMap). + @Test(groups="WIP") + public void testLocationBlank() throws Exception { + String yaml = + "location: \n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + assertTrue(app.getLocations().isEmpty(), "locs="+app.getLocations()); + } + + @Test + public void testInvalidLocationAndLocations() throws Exception { + String yaml = + "location: localhost\n"+ + "locations:\n"+ + "- localhost\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + try { + createStartWaitAndLogApplication(new StringReader(yaml)); + } catch (IllegalStateException e) { + if (!e.toString().contains("Conflicting 'location' and 'locations'")) throw e; + } + } + + @Test + public void testInvalidLocationList() throws Exception { + // should have used "locations:" instead of "location:" + String yaml = + "location:\n"+ + "- localhost\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + try { + createStartWaitAndLogApplication(new StringReader(yaml)); + } catch (IllegalStateException e) { + if (!e.toString().contains("must be a string or map")) throw e; + } + } + + @Test + public void testRootLocationPassedToChild() throws Exception { + String yaml = + "locations:\n"+ + "- localhost:(name=loc1)\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + Entity child = Iterables.getOnlyElement(app.getChildren()); + LocalhostMachineProvisioningLocation loc = (LocalhostMachineProvisioningLocation) Iterables.getOnlyElement(child.getLocations()); + assertEquals(loc.getDisplayName(), "loc1"); + } + + @Test + public void testByonYamlHosts() throws Exception { + String yaml = + "locations:\n"+ + "- byon:\n"+ + " user: root\n"+ + " privateKeyFile: /tmp/key_file\n"+ + " hosts: \n"+ + " - 127.0.0.1\n"+ + " - brooklyn@127.0.0.2\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + Entity child = Iterables.getOnlyElement(app.getChildren()); + FixedListMachineProvisioningLocation loc = (FixedListMachineProvisioningLocation) Iterables.getOnlyElement(child.getLocations()); + Assert.assertEquals(loc.getChildren().size(), 2); + + SshMachineLocation l1 = (SshMachineLocation)loc.obtain(); + assertUserAddress(l1, "root", "127.0.0.1"); + assertUserAddress((SshMachineLocation)loc.obtain(), "brooklyn", "127.0.0.2"); + Assert.assertEquals(l1.getConfig(SshMachineLocation.PRIVATE_KEY_FILE), "/tmp/key_file"); + } + + @Test + public void testByonYamlHostsString() throws Exception { + String yaml = + "locations:\n"+ + "- byon:\n"+ + " user: root\n"+ + " hosts: \"{127.0.{0,127}.{1-2},brooklyn@127.0.0.127}\"\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + Entity child = Iterables.getOnlyElement(app.getChildren()); + FixedListMachineProvisioningLocation loc = (FixedListMachineProvisioningLocation) Iterables.getOnlyElement(child.getLocations()); + Assert.assertEquals(loc.getChildren().size(), 5); + + assertUserAddress((SshMachineLocation)loc.obtain(), "root", "127.0.0.1"); + assertUserAddress((SshMachineLocation)loc.obtain(), "root", "127.0.0.2"); + assertUserAddress((SshMachineLocation)loc.obtain(), "root", "127.0.127.1"); + assertUserAddress((SshMachineLocation)loc.obtain(), "root", "127.0.127.2"); + assertUserAddress((SshMachineLocation)loc.obtain(), "brooklyn", "127.0.0.127"); + } + + @Test + public void testMultiByonYaml() throws Exception { + String yaml = + "locations:\n"+ + "- multi:\n"+ + " targets:\n"+ + " - byon:\n"+ + " user: root\n"+ + " hosts: 127.0.{0,127}.{1-2}\n"+ + " - byon:\n"+ + " user: brooklyn\n"+ + " hosts:\n"+ + " - 127.0.0.127\n"+ + "services:\n"+ + "- serviceType: brooklyn.test.entity.TestEntity\n"; + + Entity app = createStartWaitAndLogApplication(new StringReader(yaml)); + Entity child = Iterables.getOnlyElement(app.getChildren()); + MultiLocation loc = (MultiLocation) Iterables.getOnlyElement(child.getLocations()); + Assert.assertEquals(loc.getSubLocations().size(), 2); + + assertUserAddress((SshMachineLocation)loc.obtain(), "root", "127.0.0.1"); + assertUserAddress((SshMachineLocation)loc.obtain(), "root", "127.0.0.2"); + assertUserAddress((SshMachineLocation)loc.obtain(), "root", "127.0.127.1"); + assertUserAddress((SshMachineLocation)loc.obtain(), "root", "127.0.127.2"); + assertUserAddress((SshMachineLocation)loc.obtain(), "brooklyn", "127.0.0.127"); + } + + public static void assertUserAddress(MachineLocation l, String user, String address) { + Assert.assertEquals(l.getAddress().getHostAddress(), address); + if (!Strings.isBlank(user)) Assert.assertEquals(((SshMachineLocation)l).getUser(), user); + } + + @Override + protected Logger getLogger() { + return log; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/MapReferenceYamlTest.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/MapReferenceYamlTest.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/MapReferenceYamlTest.java new file mode 100644 index 0000000..bd000e9 --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/MapReferenceYamlTest.java @@ -0,0 +1,130 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import java.util.Map; +import java.util.concurrent.Callable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.testng.Assert; +import org.testng.annotations.Test; + +import brooklyn.entity.Entity; +import brooklyn.entity.basic.BasicEntity; +import brooklyn.entity.basic.Entities; +import brooklyn.entity.proxy.ProxySslConfig; +import brooklyn.test.entity.TestEntity; +import brooklyn.util.task.Tasks; + +import com.google.common.collect.Iterables; + +@Test +public class MapReferenceYamlTest extends AbstractYamlTest { + private static final Logger log = LoggerFactory.getLogger(MapReferenceYamlTest.class); + + protected Entity setupAndCheckTestEntityInBasicYamlWith(String ...extras) throws Exception { + Entity app = createAndStartApplication(loadYaml("test-entity-reference-map-template.yaml", extras)); + waitForApplicationTasks(app); + + Assert.assertEquals(app.getDisplayName(), "test-entity-reference-map-template"); + + log.info("App started:"); + Entities.dumpInfo(app); + + Assert.assertEquals(Iterables.size(app.getChildren()), 3, "Expected app to have child entity"); + Iterable basicEntities = Iterables.filter(app.getChildren(), BasicEntity.class); + Iterable testEntities = Iterables.filter(app.getChildren(), TestEntity.class); + Assert.assertEquals(Iterables.size(basicEntities), 2, "Expected app to have two basic entities"); + Assert.assertEquals(Iterables.size(testEntities), 1, "Expected app to have one test entity"); + + return Iterables.getOnlyElement(testEntities); + } + + @Test + public void testSingleEntity() throws Exception { + setupAndCheckTestEntityInBasicYamlWith(); + } + + @Test + public void testBrooklynConfigWithMapFunction() throws Exception { + final Entity testEntity = setupAndCheckTestEntityInBasicYamlWith( + " brooklyn.config:", + " test.confMapThing.obj:", + " frog: $brooklyn:formatString(\"%s\", \"frog\")", + " object:", + " $brooklyn:object:", + " type: brooklyn.entity.proxy.ProxySslConfig", + " one: $brooklyn:entity(\"one\")", + " two: $brooklyn:entity(\"two\")"); + + Map testMap = (Map) Entities.submit(testEntity, Tasks.builder().body(new Callable() { + @Override + public Object call() throws Exception { + return testEntity.getConfig(TestEntity.CONF_MAP_THING_OBJECT); + } + }).build()).get(); + Object frog = testMap.get("frog"); + Object one = testMap.get("one"); + Object two = testMap.get("two"); + Object object = testMap.get("object"); + + Assert.assertTrue(frog instanceof String, "Should have found a String: " + frog); + Assert.assertEquals(frog, "frog", "Should have found a formatted String: " + frog); + Assert.assertTrue(object instanceof ProxySslConfig, "Should have found a ProxySslConfig: " + object); + Assert.assertTrue(one instanceof BasicEntity, "Should have found a BasicEntity: " + one); + Assert.assertTrue(two instanceof BasicEntity, "Should have found a BasicEntity: " + two); + } + + @Test + public void testBrooklynConfigWithPlainMapFunction() throws Exception { + final Entity testEntity = setupAndCheckTestEntityInBasicYamlWith( + " brooklyn.config:", + " test.confMapPlain:", + " frog: $brooklyn:formatString(\"%s\", \"frog\")", + " object:", + " $brooklyn:object:", + " type: brooklyn.entity.proxy.ProxySslConfig", + " one: $brooklyn:entity(\"one\")", + " two: $brooklyn:entity(\"two\")"); + + Map testMap = (Map) Entities.submit(testEntity, Tasks.builder().body(new Callable() { + @Override + public Object call() throws Exception { + return testEntity.getConfig(TestEntity.CONF_MAP_PLAIN); + } + }).build()).get(); + Object frog = testMap.get("frog"); + Object one = testMap.get("one"); + Object two = testMap.get("two"); + Object object = testMap.get("object"); + + Assert.assertTrue(frog instanceof String, "Should have found a String: " + frog); + Assert.assertEquals(frog, "frog", "Should have found a formatted String: " + frog); + Assert.assertTrue(object instanceof ProxySslConfig, "Should have found a ProxySslConfig: " + object); + Assert.assertTrue(one instanceof BasicEntity, "Should have found a BasicEntity: " + one); + Assert.assertTrue(two instanceof BasicEntity, "Should have found a BasicEntity: " + two); + } + + @Override + protected Logger getLogger() { + return log; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ObjectsYamlTest.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ObjectsYamlTest.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ObjectsYamlTest.java new file mode 100644 index 0000000..174b5bf --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ObjectsYamlTest.java @@ -0,0 +1,280 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import java.util.List; +import java.util.concurrent.atomic.AtomicBoolean; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.testng.Assert; +import org.testng.annotations.Test; + +import brooklyn.config.ConfigKey; +import brooklyn.config.ConfigKey.HasConfigKey; +import brooklyn.entity.Entity; +import brooklyn.entity.basic.ConfigKeys; +import brooklyn.entity.basic.Entities; +import brooklyn.entity.proxy.ProxySslConfig; +import brooklyn.entity.trait.Configurable; +import brooklyn.management.ManagementContext; +import brooklyn.management.ManagementContextInjectable; +import brooklyn.management.Task; +import brooklyn.test.entity.TestEntity; +import brooklyn.util.config.ConfigBag; +import brooklyn.util.flags.SetFromFlag; +import brooklyn.util.flags.TypeCoercions; + +import com.google.common.collect.Lists; + +@Test +public class ObjectsYamlTest extends AbstractYamlTest { + private static final Logger log = LoggerFactory.getLogger(ObjectsYamlTest.class); + + private static final AtomicBoolean managementContextInjected = new AtomicBoolean(false); + private static final List configKeys = Lists.newLinkedList(); + + public static class TestObject implements ManagementContextInjectable { + private String string; + private Integer number; + private Object object; + + public TestObject() { } + + public String getString() { return string; } + public void setString(String string) { this.string = string; } + + public Integer getNumber() { return number; } + public void setNumber(Integer number) { this.number = number; } + + public Object getObject() { return object; } + public void setObject(Object object) { this.object = object; } + + @Override + public void injectManagementContext(ManagementContext managementContext) { + log.info("Detected injection of {}", managementContext); + managementContextInjected.set(true); + } + } + + public static class ConfigurableObject implements Configurable { + public static final ConfigKey INTEGER = ConfigKeys.newIntegerConfigKey("config.number"); + @SetFromFlag("object") + public static final ConfigKey OBJECT = ConfigKeys.newConfigKey(Object.class, "config.object"); + + @SetFromFlag("flag") + private String string; + + private Integer number; + private Object object; + private Double value; + BasicConfigurationSupport configSupport = new BasicConfigurationSupport(); + + public ConfigurableObject() { } + + public String getString() { return string; } + + public Integer getNumber() { return number; } + + public Object getObject() { return object; } + + public Double getDouble() { return value; } + public void setDouble(Double value) { this.value = value; } + + @Override + public T setConfig(ConfigKey key, T value) { + return config().set(key, value); + } + + @Override + public ConfigurationSupport config() { + return configSupport; + } + + private class BasicConfigurationSupport implements ConfigurationSupport { + private final ConfigBag bag = new ConfigBag(); + + @Override + public T get(ConfigKey key) { + return bag.get(key); + } + + @Override + public T get(HasConfigKey key) { + return get(key.getConfigKey()); + } + + @Override + public T set(ConfigKey key, T val) { + log.info("Detected configuration injection for {}: {}", key.getName(), val); + configKeys.add(key.getName()); + if ("config.number".equals(key.getName())) number = TypeCoercions.coerce(val, Integer.class); + if ("config.object".equals(key.getName())) object = val; + T old = bag.get(key); + bag.configure(key, val); + return old; + } + + @Override + public T set(HasConfigKey key, T val) { + return set(key.getConfigKey(), val); + } + + @Override + public T set(ConfigKey key, Task val) { + throw new UnsupportedOperationException(); + } + + @Override + public T set(HasConfigKey key, Task val) { + return set(key.getConfigKey(), val); + } + } + } + + protected Entity setupAndCheckTestEntityInBasicYamlWith(String ...extras) throws Exception { + managementContextInjected.set(false); + configKeys.clear(); + Entity app = createAndStartApplication(loadYaml("test-entity-basic-template.yaml", extras)); + waitForApplicationTasks(app); + + Assert.assertEquals(app.getDisplayName(), "test-entity-basic-template"); + + log.info("App started:"); + Entities.dumpInfo(app); + + Assert.assertTrue(app.getChildren().iterator().hasNext(), "Expected app to have child entity"); + Entity entity = app.getChildren().iterator().next(); + Assert.assertTrue(entity instanceof TestEntity, "Expected TestEntity, found " + entity.getClass()); + + return (TestEntity)entity; + } + + @Test + public void testSingleEntity() throws Exception { + setupAndCheckTestEntityInBasicYamlWith(); + } + + @Test + public void testBrooklynObject() throws Exception { + Entity testEntity = setupAndCheckTestEntityInBasicYamlWith( + " brooklyn.config:", + " test.confObject:", + " $brooklyn:object:", + " type: "+ObjectsYamlTest.class.getName()+"$TestObject", + " object.fields:", + " number: 7", + " object:", + " $brooklyn:object:", + " type: brooklyn.entity.proxy.ProxySslConfig", + " string: \"frog\""); + + Object testObject = testEntity.getConfig(TestEntity.CONF_OBJECT); + + Assert.assertTrue(testObject instanceof TestObject, "Expected a TestObject: "+testObject); + Assert.assertTrue(managementContextInjected.get()); + Assert.assertEquals(((TestObject) testObject).getNumber(), Integer.valueOf(7)); + Assert.assertEquals(((TestObject) testObject).getString(), "frog"); + + Object testObjectObject = ((TestObject) testObject).getObject(); + Assert.assertTrue(testObjectObject instanceof ProxySslConfig, "Expected a ProxySslConfig: "+testObjectObject); + } + + @Test + public void testBrooklynConfigurableObject() throws Exception { + Entity testEntity = setupAndCheckTestEntityInBasicYamlWith( + " brooklyn.config:", + " test.confObject:", + " $brooklyn:object:", + " type: "+ObjectsYamlTest.class.getName()+"$ConfigurableObject", + " object.fields:", + " double: 1.4", + " brooklyn.config:", + " flag: frog", + " config.number: 7", + " object:", + " $brooklyn:object:", + " type: brooklyn.entity.proxy.ProxySslConfig"); + + Object testObject = testEntity.getConfig(TestEntity.CONF_OBJECT); + + Assert.assertTrue(testObject instanceof ConfigurableObject, "Expected a ConfigurableObject: "+testObject); + Assert.assertEquals(((ConfigurableObject) testObject).getDouble(), Double.valueOf(1.4)); + Assert.assertEquals(((ConfigurableObject) testObject).getString(), "frog"); + Assert.assertEquals(((ConfigurableObject) testObject).getNumber(), Integer.valueOf(7)); + + Object testObjectObject = ((ConfigurableObject) testObject).getObject(); + Assert.assertTrue(testObjectObject instanceof ProxySslConfig, "Expected a ProxySslConfig: "+testObjectObject); + + Assert.assertTrue(configKeys.contains(ConfigurableObject.INTEGER.getName()), "Expected INTEGER key: "+configKeys); + Assert.assertTrue(configKeys.contains(ConfigurableObject.OBJECT.getName()), "Expected OBJECT key: "+configKeys); + } + + @Test + public void testBrooklynObjectPrefix() throws Exception { + Entity testEntity = setupAndCheckTestEntityInBasicYamlWith( + " brooklyn.config:", + " test.confListPlain:", + " - $brooklyn:object:", + " objectType: brooklyn.entity.proxy.ProxySslConfig", + " - $brooklyn:object:", + " object_type: brooklyn.entity.proxy.ProxySslConfig", + " - $brooklyn:object:", + " type: brooklyn.entity.proxy.ProxySslConfig"); + + List testList = testEntity.getConfig(TestEntity.CONF_LIST_PLAIN); + + Assert.assertEquals(testList.size(), 3); + for (Object entry : testList) { + Assert.assertTrue(entry instanceof ProxySslConfig, "Expected a ProxySslConfig: "+entry); + } + } + + @Test + public void testBrooklynObjectWithFunction() throws Exception { + Entity testEntity = setupAndCheckTestEntityInBasicYamlWith( + " brooklyn.config:", + " test.confObject:", + " $brooklyn:object:", + " type: "+ObjectsYamlTest.class.getName()+"$TestObject", + " object.fields:", + " number: 7", + " object:", + " $brooklyn:object:", + " type: brooklyn.entity.proxy.ProxySslConfig", + " string:", + " $brooklyn:formatString(\"%s\", \"frog\")"); + + Object testObject = testEntity.getConfig(TestEntity.CONF_OBJECT); + + Assert.assertTrue(testObject instanceof TestObject, "Expected a TestObject: "+testObject); + Assert.assertTrue(managementContextInjected.get()); + Assert.assertEquals(((TestObject) testObject).getNumber(), Integer.valueOf(7)); + Assert.assertEquals(((TestObject) testObject).getString(), "frog"); + + Object testObjectObject = ((TestObject) testObject).getObject(); + Assert.assertTrue(testObjectObject instanceof ProxySslConfig, "Expected a ProxySslConfig: "+testObjectObject); + } + + @Override + protected Logger getLogger() { + return log; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/PoliciesYamlTest.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/PoliciesYamlTest.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/PoliciesYamlTest.java new file mode 100644 index 0000000..241fefb --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/PoliciesYamlTest.java @@ -0,0 +1,215 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import java.util.Map; +import java.util.concurrent.Callable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.testng.Assert; +import org.testng.annotations.Test; + +import brooklyn.config.ConfigKey; +import brooklyn.entity.Entity; +import brooklyn.entity.basic.Entities; +import brooklyn.entity.basic.EntityInternal; +import brooklyn.policy.Policy; +import brooklyn.test.Asserts; +import brooklyn.test.entity.TestEntity; +import brooklyn.test.policy.TestPolicy; +import brooklyn.util.collections.MutableMap; + +import com.google.common.base.Predicates; +import com.google.common.base.Supplier; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; + +@Test +public class PoliciesYamlTest extends AbstractYamlTest { + static final Logger log = LoggerFactory.getLogger(PoliciesYamlTest.class); + + @Test + public void testWithAppPolicy() throws Exception { + Entity app = createAndStartApplication(loadYaml("test-app-with-policy.yaml")); + waitForApplicationTasks(app); + Assert.assertEquals(app.getDisplayName(), "test-app-with-policy"); + + log.info("App started:"); + Entities.dumpInfo(app); + + Assert.assertEquals(app.getPolicies().size(), 1); + Policy policy = app.getPolicies().iterator().next(); + Assert.assertTrue(policy instanceof TestPolicy); + Assert.assertEquals(policy.getConfig(TestPolicy.CONF_NAME), "Name from YAML"); + Assert.assertEquals(policy.getConfig(TestPolicy.CONF_FROM_FUNCTION), "$brooklyn: is a fun place"); + Map leftoverProperties = ((TestPolicy) policy).getLeftoverProperties(); + Assert.assertEquals(leftoverProperties.get("policyLiteralValue1"), "Hello"); + Assert.assertEquals(leftoverProperties.get("policyLiteralValue2"), "World"); + Assert.assertEquals(leftoverProperties.size(), 2); + } + + @Test + public void testWithEntityPolicy() throws Exception { + Entity app = createAndStartApplication(loadYaml("test-entity-with-policy.yaml")); + waitForApplicationTasks(app); + Assert.assertEquals(app.getDisplayName(), "test-entity-with-policy"); + + log.info("App started:"); + Entities.dumpInfo(app); + + Assert.assertEquals(app.getPolicies().size(), 0); + Assert.assertEquals(app.getChildren().size(), 1); + Entity child = app.getChildren().iterator().next(); + Assert.assertEquals(child.getPolicies().size(), 1); + Policy policy = child.getPolicies().iterator().next(); + Assert.assertNotNull(policy); + Assert.assertTrue(policy instanceof TestPolicy, "policy=" + policy + "; type=" + policy.getClass()); + Assert.assertEquals(policy.getConfig(TestPolicy.CONF_NAME), "Name from YAML"); + Assert.assertEquals(policy.getConfig(TestPolicy.CONF_FROM_FUNCTION), "$brooklyn: is a fun place"); + Assert.assertEquals(((TestPolicy) policy).getLeftoverProperties(), + ImmutableMap.of("policyLiteralValue1", "Hello", "policyLiteralValue2", "World")); + Assert.assertEquals(policy.getConfig(TestPolicy.TEST_ATTRIBUTE_SENSOR), TestEntity.NAME); + } + + @Test + public void testChildWithPolicy() throws Exception { + Entity app = createAndStartApplication(loadYaml("test-entity-basic-template.yaml", + " brooklyn.config:", + " test.confName: parent entity", + " brooklyn.children:", + " - serviceType: brooklyn.test.entity.TestEntity", + " name: Child Entity", + " brooklyn.policies:", + " - policyType: brooklyn.test.policy.TestPolicy", + " brooklyn.config:", + " test.confName: Name from YAML", + " test.attributeSensor: $brooklyn:sensor(\"brooklyn.test.entity.TestEntity\", \"test.name\")")); + waitForApplicationTasks(app); + + Assert.assertEquals(app.getChildren().size(), 1); + Entity firstEntity = app.getChildren().iterator().next(); + Assert.assertEquals(firstEntity.getChildren().size(), 1); + final Entity child = firstEntity.getChildren().iterator().next(); + Assert.assertEquals(child.getChildren().size(), 0); + + Assert.assertEquals(app.getPolicies().size(), 0); + Assert.assertEquals(firstEntity.getPolicies().size(), 0); + + Asserts.eventually(new Supplier() { + @Override + public Integer get() { + return child.getPolicies().size(); + } + }, Predicates. equalTo(1)); + + Policy policy = child.getPolicies().iterator().next(); + Assert.assertTrue(policy instanceof TestPolicy); + Assert.assertEquals(policy.getConfig(TestPolicy.TEST_ATTRIBUTE_SENSOR), TestEntity.NAME); + } + + @Test + public void testMultiplePolicyReferences() throws Exception { + final Entity app = createAndStartApplication(loadYaml("test-referencing-policies.yaml")); + waitForApplicationTasks(app); + Assert.assertEquals(app.getDisplayName(), "test-referencing-policies"); + + Entity entity1 = null, entity2 = null, child1 = null, child2 = null, grandchild1 = null, grandchild2 = null; + + Assert.assertEquals(app.getChildren().size(), 2); + for (Entity child : app.getChildren()) { + if (child.getDisplayName().equals("entity 1")) + entity1 = child; + if (child.getDisplayName().equals("entity 2")) + entity2 = child; + } + Assert.assertNotNull(entity1); + Assert.assertNotNull(entity2); + + Assert.assertEquals(entity1.getChildren().size(), 2); + for (Entity child : entity1.getChildren()) { + if (child.getDisplayName().equals("child 1")) + child1 = child; + if (child.getDisplayName().equals("child 2")) + child2 = child; + } + Assert.assertNotNull(child1); + Assert.assertNotNull(child2); + + Assert.assertEquals(child1.getChildren().size(), 2); + for (Entity child : child1.getChildren()) { + if (child.getDisplayName().equals("grandchild 1")) + grandchild1 = child; + if (child.getDisplayName().equals("grandchild 2")) + grandchild2 = child; + } + Assert.assertNotNull(grandchild1); + Assert.assertNotNull(grandchild2); + + ImmutableSet policies = new ImmutableSet.Builder() + .add(getPolicy(app)) + .add(getPolicy(entity1)) + .add(getPolicy(entity2)) + .add(getPolicy(child1)) + .add(getPolicy(child2)) + .add(getPolicy(grandchild1)) + .add(getPolicy(grandchild2)) + .build(); + + Map, Entity> keyToEntity = new ImmutableMap.Builder, Entity>() + .put(ReferencingYamlTestEntity.TEST_REFERENCE_APP, app) + .put(ReferencingYamlTestEntity.TEST_REFERENCE_ENTITY1, entity1) + .put(ReferencingYamlTestEntity.TEST_REFERENCE_ENTITY2, entity2) + .put(ReferencingYamlTestEntity.TEST_REFERENCE_CHILD1, child1) + .put(ReferencingYamlTestEntity.TEST_REFERENCE_CHILD2, child2) + .put(ReferencingYamlTestEntity.TEST_REFERENCE_GRANDCHILD1, grandchild1) + .put(ReferencingYamlTestEntity.TEST_REFERENCE_GRANDCHILD2, grandchild2) + .build(); + + for (Policy policy : policies) + checkReferences(policy, keyToEntity); + + } + + private void checkReferences(final Policy policy, Map, Entity> keyToEntity) throws Exception { + for (final ConfigKey key : keyToEntity.keySet()) { + final Entity entity = keyToEntity.get(key); // Grab an entity whose execution context we can use + Entity fromConfig = ((EntityInternal)entity).getExecutionContext().submit(MutableMap.of(), new Callable() { + @Override + public Entity call() throws Exception { + return (Entity) policy.getConfig(key); + } + }).get(); + Assert.assertEquals(fromConfig, keyToEntity.get(key)); + } + } + + private Policy getPolicy(Entity entity) { + Assert.assertEquals(entity.getPolicies().size(), 1); + Policy policy = entity.getPolicies().iterator().next(); + Assert.assertTrue(policy instanceof TestReferencingPolicy); + return policy; + } + + @Override + protected Logger getLogger() { + return log; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencedYamlTest.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencedYamlTest.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencedYamlTest.java new file mode 100644 index 0000000..1d1997e --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencedYamlTest.java @@ -0,0 +1,180 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import java.util.Collection; + +import org.apache.brooklyn.test.TestResourceUnavailableException; +import org.testng.Assert; +import org.testng.annotations.Test; + +import brooklyn.entity.Entity; +import brooklyn.entity.basic.BasicApplication; +import brooklyn.entity.basic.BasicEntity; +import brooklyn.management.osgi.OsgiStandaloneTest; + +import com.google.common.collect.Iterables; + +public class ReferencedYamlTest extends AbstractYamlTest { + + @Test + public void testReferenceEntityYamlAsPlatformComponent() throws Exception { + String entityName = "Reference child name"; + Entity app = createAndStartApplication( + "services:", + "- name: " + entityName, + " type: classpath://yaml-ref-entity.yaml"); + + checkChildEntitySpec(app, entityName); + } + + @Test + public void testAnonymousReferenceEntityYamlAsPlatformComponent() throws Exception { + Entity app = createAndStartApplication( + "services:", + "- type: classpath://yaml-ref-entity.yaml"); + + checkChildEntitySpec(app, "service"); + } + + @Test + public void testReferenceAppYamlAsPlatformComponent() throws Exception { + Entity app = createAndStartApplication( + "services:", + "- name: Reference child name", + " type: classpath://yaml-ref-app.yaml"); + + Assert.assertEquals(app.getChildren().size(), 0); + Assert.assertEquals(app.getDisplayName(), "Reference child name"); + + //child is a proxy so equality test won't do + Assert.assertEquals(app.getEntityType().getName(), BasicApplication.class.getName()); + } + + @Test + public void testReferenceYamlAsChild() throws Exception { + String entityName = "Reference child name"; + Entity createAndStartApplication = createAndStartApplication( + "services:", + "- type: brooklyn.entity.basic.BasicEntity", + " brooklyn.children:", + " - name: " + entityName, + " type: classpath://yaml-ref-entity.yaml"); + + checkGrandchildEntitySpec(createAndStartApplication, entityName); + } + + @Test + public void testAnonymousReferenceYamlAsChild() throws Exception { + Entity createAndStartApplication = createAndStartApplication( + "services:", + "- type: brooklyn.entity.basic.BasicEntity", + " brooklyn.children:", + " - type: classpath://yaml-ref-entity.yaml"); + + checkGrandchildEntitySpec(createAndStartApplication, "service"); + } + + @Test + public void testCatalogReferencingYamlUrl() throws Exception { + addCatalogItems( + "brooklyn.catalog:", + " id: yaml.reference", + " version: " + TEST_VERSION, + "services:", + "- type: classpath://yaml-ref-entity.yaml"); + + String entityName = "YAML -> catalog item -> yaml url"; + Entity app = createAndStartApplication( + "services:", + "- name: " + entityName, + " type: " + ver("yaml.reference")); + + checkChildEntitySpec(app, entityName); + } + + @Test + public void testYamlUrlReferencingCatalog() throws Exception { + addCatalogItems( + "brooklyn.catalog:", + " id: yaml.basic", + " version: " + TEST_VERSION, + "services:", + "- type: brooklyn.entity.basic.BasicEntity"); + + String entityName = "YAML -> yaml url -> catalog item"; + Entity app = createAndStartApplication( + "services:", + "- name: " + entityName, + " type: classpath://yaml-ref-catalog.yaml"); + + checkChildEntitySpec(app, entityName); + } + + /** + * Tests that a YAML referenced by URL from a catalog item + * will have access to the catalog item's bundles. + */ + @Test + public void testCatalogLeaksBundlesToReferencedYaml() throws Exception { + TestResourceUnavailableException.throwIfResourceUnavailable(getClass(), OsgiStandaloneTest.BROOKLYN_TEST_OSGI_ENTITIES_PATH); + + String parentCatalogId = "my.catalog.app.id.url.parent"; + addCatalogItems( + "brooklyn.catalog:", + " id: " + parentCatalogId, + " version: " + TEST_VERSION, + " libraries:", + " - url: " + OsgiStandaloneTest.BROOKLYN_TEST_OSGI_ENTITIES_URL, + "", + "services:", + "- type: classpath://yaml-ref-bundle-without-libraries.yaml"); + + Entity app = createAndStartApplication( + "services:", + "- type: " + ver(parentCatalogId)); + + Collection children = app.getChildren(); + Assert.assertEquals(children.size(), 1); + Entity child = Iterables.getOnlyElement(children); + Assert.assertEquals(child.getEntityType().getName(), "brooklyn.osgi.tests.SimpleEntity"); + + deleteCatalogEntity(parentCatalogId); + } + + private void checkChildEntitySpec(Entity app, String entityName) { + Collection children = app.getChildren(); + Assert.assertEquals(children.size(), 1); + Entity child = Iterables.getOnlyElement(children); + Assert.assertEquals(child.getDisplayName(), entityName); + Assert.assertEquals(child.getEntityType().getName(), BasicEntity.class.getName()); + } + + private void checkGrandchildEntitySpec(Entity createAndStartApplication, String entityName) { + Collection children = createAndStartApplication.getChildren(); + Assert.assertEquals(children.size(), 1); + Entity child = Iterables.getOnlyElement(children); + Collection grandChildren = child.getChildren(); + Assert.assertEquals(grandChildren.size(), 1); + Entity grandChild = Iterables.getOnlyElement(grandChildren); + Assert.assertEquals(grandChild.getDisplayName(), entityName); + Assert.assertEquals(grandChild.getEntityType().getName(), BasicEntity.class.getName()); + } + +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencingYamlTestEntity.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencingYamlTestEntity.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencingYamlTestEntity.java new file mode 100644 index 0000000..bab503d --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencingYamlTestEntity.java @@ -0,0 +1,66 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import brooklyn.config.ConfigKey; +import brooklyn.entity.Entity; +import brooklyn.entity.proxying.ImplementedBy; +import brooklyn.event.basic.BasicConfigKey; + +import com.google.common.reflect.TypeToken; + +@ImplementedBy(ReferencingYamlTestEntityImpl.class) +public interface ReferencingYamlTestEntity extends Entity { + @SuppressWarnings("serial") + public static final ConfigKey TEST_REFERENCE_APP = BasicConfigKey.builder(new TypeToken(){}) + .name("test.reference.app") + .build(); + @SuppressWarnings("serial") + public static final ConfigKey TEST_REFERENCE_ENTITY1 = BasicConfigKey.builder(new TypeToken(){}) + .name("test.reference.entity1") + .build(); + @SuppressWarnings("serial") + public static final ConfigKey TEST_REFERENCE_ENTITY1_ALT = BasicConfigKey.builder(new TypeToken(){}) + .name("test.reference.entity1a") + .build(); + @SuppressWarnings("serial") + public static final ConfigKey TEST_REFERENCE_ENTITY2 = BasicConfigKey.builder(new TypeToken(){}) + .name("test.reference.entity2") + .build(); + @SuppressWarnings("serial") + public static final ConfigKey TEST_REFERENCE_CHILD1 = BasicConfigKey.builder(new TypeToken(){}) + .name("test.reference.child1") + .build(); + @SuppressWarnings("serial") + public static final ConfigKey TEST_REFERENCE_CHILD2 = BasicConfigKey.builder(new TypeToken(){}) + .name("test.reference.child2") + .build(); + @SuppressWarnings("serial") + public static final ConfigKey TEST_REFERENCE_GRANDCHILD1 = BasicConfigKey.builder(new TypeToken(){}) + .name("test.reference.grandchild1") + .build(); + @SuppressWarnings("serial") + public static final ConfigKey TEST_REFERENCE_GRANDCHILD2 = BasicConfigKey.builder(new TypeToken(){}) + .name("test.reference.grandchild2") + .build(); + @SuppressWarnings("serial") + public static final ConfigKey TEST_REFERENCE_BOGUS = BasicConfigKey.builder(new TypeToken(){}) + .name("test.reference.bogus") + .build(); +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencingYamlTestEntityImpl.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencingYamlTestEntityImpl.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencingYamlTestEntityImpl.java new file mode 100644 index 0000000..4d98c6b --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReferencingYamlTestEntityImpl.java @@ -0,0 +1,25 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import brooklyn.entity.basic.AbstractApplication; + +public class ReferencingYamlTestEntityImpl extends AbstractApplication implements ReferencingYamlTestEntity { + +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReloadBrooklynPropertiesTest.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReloadBrooklynPropertiesTest.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReloadBrooklynPropertiesTest.java new file mode 100644 index 0000000..23aa759 --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/ReloadBrooklynPropertiesTest.java @@ -0,0 +1,89 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import io.brooklyn.camp.CampPlatform; +import io.brooklyn.camp.spi.Assembly; +import io.brooklyn.camp.spi.AssemblyTemplate; + +import java.io.Reader; + +import org.apache.brooklyn.camp.brooklyn.BrooklynCampConstants; +import org.apache.brooklyn.camp.brooklyn.BrooklynCampPlatformLauncherNoServer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.testng.Assert; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import brooklyn.entity.Entity; +import brooklyn.entity.basic.Entities; +import brooklyn.entity.trait.Startable; +import brooklyn.management.ManagementContext; +import brooklyn.test.EntityTestUtils; +import brooklyn.util.ResourceUtils; +import brooklyn.util.exceptions.Exceptions; +import brooklyn.util.stream.Streams; + +public class ReloadBrooklynPropertiesTest { + + private static final Logger LOG = LoggerFactory.getLogger(ReloadBrooklynPropertiesTest.class); + + private ManagementContext brooklynMgmt; + + @BeforeMethod(alwaysRun=true) + public void setup() { + brooklynMgmt = new BrooklynCampPlatformLauncherNoServer().launch().getBrooklynMgmt(); + } + + @AfterMethod(alwaysRun=true) + public void teardown() { + if (brooklynMgmt!=null) Entities.destroyAll(brooklynMgmt); + } + + @Test + public void testReloadBrooklynPropertiesNonDeploy() { + CampPlatform platform = brooklynMgmt.getConfig().getConfig(BrooklynCampConstants.CAMP_PLATFORM); + Assert.assertNotNull(platform); + brooklynMgmt.reloadBrooklynProperties(); + CampPlatform reloadedPlatform = brooklynMgmt.getConfig().getConfig(BrooklynCampConstants.CAMP_PLATFORM); + Assert.assertEquals(reloadedPlatform, platform); + } + + @Test + public void testReloadBrooklynPropertiesDeploy() { + brooklynMgmt.reloadBrooklynProperties(); + CampPlatform reloadedPlatform = brooklynMgmt.getConfig().getConfig(BrooklynCampConstants.CAMP_PLATFORM); + Assert.assertNotNull(reloadedPlatform); + Reader input = Streams.reader(new ResourceUtils(this).getResourceFromUrl("test-entity-basic-template.yaml")); + AssemblyTemplate template = reloadedPlatform.pdp().registerDeploymentPlan(input); + try { + Assembly assembly = template.getInstantiator().newInstance().instantiate(template, reloadedPlatform); + LOG.info("Test - created " + assembly); + final Entity app = brooklynMgmt.getEntityManager().getEntity(assembly.getId()); + LOG.info("App - " + app); + Assert.assertEquals(app.getDisplayName(), "test-entity-basic-template"); + EntityTestUtils.assertAttributeEqualsEventually(app, Startable.SERVICE_UP, true); + } catch (Exception e) { + LOG.warn("Unable to instantiate " + template + " (rethrowing): " + e); + throw Exceptions.propagate(e); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestEntityWithInitConfig.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestEntityWithInitConfig.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestEntityWithInitConfig.java new file mode 100644 index 0000000..2e557c7 --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestEntityWithInitConfig.java @@ -0,0 +1,35 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import brooklyn.config.ConfigKey; +import brooklyn.entity.Entity; +import brooklyn.entity.basic.EntityInternal; +import brooklyn.entity.basic.EntityLocal; +import brooklyn.entity.proxying.ImplementedBy; +import brooklyn.entity.trait.Startable; +import brooklyn.event.basic.BasicConfigKey; + +@ImplementedBy(TestEntityWithInitConfigImpl.class) +public interface TestEntityWithInitConfig extends Entity, Startable, EntityLocal, EntityInternal { + public static final ConfigKey TEST_ENTITY = BasicConfigKey.builder(Entity.class) + .name("test.entity") + .build(); + public Entity getEntityCachedOnInit(); +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestEntityWithInitConfigImpl.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestEntityWithInitConfigImpl.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestEntityWithInitConfigImpl.java new file mode 100644 index 0000000..b17ce4f --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestEntityWithInitConfigImpl.java @@ -0,0 +1,59 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import java.util.Collection; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import brooklyn.entity.Entity; +import brooklyn.entity.basic.AbstractEntity; +import brooklyn.location.Location; + +public class TestEntityWithInitConfigImpl extends AbstractEntity implements TestEntityWithInitConfig { + + private static final Logger LOG = LoggerFactory.getLogger(TestEntityWithInitConfigImpl.class); + private Entity entityCachedOnInit; + + @Override + public void init() { + super.init(); + entityCachedOnInit = getConfig(TEST_ENTITY); + } + + @Override + public void start(Collection locations) { + LOG.trace("Starting {}", this); + } + + @Override + public void stop() { + LOG.trace("Stopping {}", this); + } + + @Override + public void restart() { + LOG.trace("Restarting {}", this); + } + + public Entity getEntityCachedOnInit() { + return entityCachedOnInit; + } +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestReferencingEnricher.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestReferencingEnricher.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestReferencingEnricher.java new file mode 100644 index 0000000..2db2667 --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestReferencingEnricher.java @@ -0,0 +1,34 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import brooklyn.config.ConfigKey; +import brooklyn.enricher.basic.AbstractEnricher; +import brooklyn.entity.Entity; +import brooklyn.event.basic.BasicConfigKey; + +public class TestReferencingEnricher extends AbstractEnricher { + public static final ConfigKey TEST_APPLICATION = new BasicConfigKey(Entity.class, "test.reference.app"); + public static final ConfigKey TEST_ENTITY_1 = new BasicConfigKey(Entity.class, "test.reference.entity1"); + public static final ConfigKey TEST_ENTITY_2 = new BasicConfigKey(Entity.class, "test.reference.entity2"); + public static final ConfigKey TEST_CHILD_1 = new BasicConfigKey(Entity.class, "test.reference.child1"); + public static final ConfigKey TEST_CHILD_2 = new BasicConfigKey(Entity.class, "test.reference.child2"); + public static final ConfigKey TEST_GRANDCHILD_1 = new BasicConfigKey(Entity.class, "test.reference.grandchild1"); + public static final ConfigKey TEST_GRANDCHILD_2 = new BasicConfigKey(Entity.class, "test.reference.grandchild2"); +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestReferencingPolicy.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestReferencingPolicy.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestReferencingPolicy.java new file mode 100644 index 0000000..0718cf4 --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestReferencingPolicy.java @@ -0,0 +1,34 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import brooklyn.config.ConfigKey; +import brooklyn.entity.Entity; +import brooklyn.event.basic.BasicConfigKey; +import brooklyn.policy.basic.AbstractPolicy; + +public class TestReferencingPolicy extends AbstractPolicy { + public static final ConfigKey TEST_APPLICATION = new BasicConfigKey(Entity.class, "test.reference.app"); + public static final ConfigKey TEST_ENTITY_1 = new BasicConfigKey(Entity.class, "test.reference.entity1"); + public static final ConfigKey TEST_ENTITY_2 = new BasicConfigKey(Entity.class, "test.reference.entity2"); + public static final ConfigKey TEST_CHILD_1 = new BasicConfigKey(Entity.class, "test.reference.child1"); + public static final ConfigKey TEST_CHILD_2 = new BasicConfigKey(Entity.class, "test.reference.child2"); + public static final ConfigKey TEST_GRANDCHILD_1 = new BasicConfigKey(Entity.class, "test.reference.grandchild1"); + public static final ConfigKey TEST_GRANDCHILD_2 = new BasicConfigKey(Entity.class, "test.reference.grandchild2"); +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestSensorAndEffectorInitializer.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestSensorAndEffectorInitializer.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestSensorAndEffectorInitializer.java new file mode 100644 index 0000000..1aa70e6 --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/TestSensorAndEffectorInitializer.java @@ -0,0 +1,86 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import java.util.Map; + +import org.testng.Assert; + +import com.google.common.base.Preconditions; + +import brooklyn.entity.Effector; +import brooklyn.entity.basic.EntityInternal; +import brooklyn.entity.basic.EntityLocal; +import brooklyn.entity.effector.EffectorBody; +import brooklyn.entity.effector.Effectors; +import brooklyn.entity.proxying.EntityInitializer; +import brooklyn.event.AttributeSensor; +import brooklyn.event.basic.Sensors; +import brooklyn.util.config.ConfigBag; + +public class TestSensorAndEffectorInitializer implements EntityInitializer { + + public static final String EFFECTOR_SAY_HELLO = "sayHello"; + public static final String SENSOR_LAST_HELLO = "lastHello"; + public static final String SENSOR_HELLO_DEFINED = "sensorHelloDefined"; + public static final String SENSOR_HELLO_DEFINED_EMITTED = "sensorHelloDefinedEmitted"; + + protected String helloWord() { return "Hello"; } + + @Override + public void apply(EntityLocal entity) { + Effector eff = Effectors.effector(String.class, EFFECTOR_SAY_HELLO).parameter(String.class, "name").impl( + new EffectorBody() { + @Override + public String call(ConfigBag parameters) { + Object name = parameters.getStringKey("name"); + entity().setAttribute(Sensors.newStringSensor(SENSOR_LAST_HELLO), ""+name); + return helloWord()+" "+name; + } + }).build(); + ((EntityInternal)entity).getMutableEntityType().addEffector(eff); + + ((EntityInternal)entity).getMutableEntityType().addSensor(Sensors.newStringSensor(SENSOR_HELLO_DEFINED)); + + AttributeSensor emitted = Sensors.newStringSensor(SENSOR_HELLO_DEFINED_EMITTED); + ((EntityInternal)entity).getMutableEntityType().addSensor(emitted); + entity.setAttribute(emitted, "1"); + } + + public static class TestConfigurableInitializer extends TestSensorAndEffectorInitializer { + public static final String HELLO_WORD = "helloWord"; + final String helloWord; + public TestConfigurableInitializer(Map params) { + Preconditions.checkNotNull(params); + if (params.containsKey(HELLO_WORD)) { + helloWord = params.get(HELLO_WORD); + Assert.assertEquals(params.size(), 1); + } else { + helloWord = "Hello"; + Assert.assertEquals(params.size(), 0); + } + } + + @Override + protected String helloWord() { + return helloWord; + } + } + +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/VanillaBashNetcatYamlTest.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/VanillaBashNetcatYamlTest.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/VanillaBashNetcatYamlTest.java new file mode 100644 index 0000000..bde5016 --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/VanillaBashNetcatYamlTest.java @@ -0,0 +1,114 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import org.apache.brooklyn.camp.brooklyn.BrooklynCampConstants; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.testng.Assert; +import org.testng.annotations.Test; + +import brooklyn.entity.Effector; +import brooklyn.entity.Entity; +import brooklyn.entity.basic.Attributes; +import brooklyn.entity.basic.Entities; +import brooklyn.entity.basic.EntityPredicates; +import brooklyn.entity.basic.Lifecycle; +import brooklyn.entity.effector.Effectors; +import brooklyn.event.AttributeSensor; +import brooklyn.event.basic.Sensors; +import brooklyn.management.Task; +import brooklyn.test.EntityTestUtils; +import brooklyn.util.collections.MutableMap; +import brooklyn.util.net.Networking; +import brooklyn.util.text.StringPredicates; + +import com.google.common.base.Preconditions; +import com.google.common.base.Predicates; +import com.google.common.collect.Iterables; + +@Test +public class VanillaBashNetcatYamlTest extends AbstractYamlTest { + + private static final Logger log = LoggerFactory.getLogger(VanillaBashNetcatYamlTest.class); + + private static final AttributeSensor SENSOR_OUTPUT_ALL = Sensors.newStringSensor("output.all"); + final static Effector EFFECTOR_SAY_HI = Effectors.effector(String.class, "sayHiNetcat").buildAbstract(); + + @Test(groups="Integration") + public void testInvocationSensorAndEnricher() throws Exception { + Preconditions.checkArgument(Networking.isPortAvailable(4321), "port 4321 must not be in use (no leaked nc instances) for this test to succeed!"); + + Entity app = createAndStartApplication(loadYaml("vanilla-bash-netcat-w-client.yaml")); + waitForApplicationTasks(app); + + log.info("App started:"); + Entities.dumpInfo(app); + + Assert.assertEquals(app.getDisplayName(), "Simple Netcat with Client"); + + // comparing by plan ID is one common way + Iterable netcatI = Iterables.filter(app.getChildren(), EntityPredicates.configEqualTo(BrooklynCampConstants.PLAN_ID, "netcat-server")); + Assert.assertTrue(netcatI.iterator().hasNext(), "no 'netcat-server' child of app: "+app.getChildren()); + Entity netcat = Iterables.getOnlyElement(netcatI); + + // make sure netcat is running + EntityTestUtils.assertAttributeEventually(netcat, Attributes.SERVICE_STATE_ACTUAL, Predicates.equalTo(Lifecycle.RUNNING)); + + // find the pinger, now comparing by name + Iterable pingerI = Iterables.filter(app.getChildren(), EntityPredicates.displayNameEqualTo("Simple Pinger")); + Assert.assertTrue(pingerI.iterator().hasNext(), "no 'Simple Pinger' child of app: "+app.getChildren()); + Entity pinger = Iterables.getOnlyElement(pingerI); + + // invoke effector + Task ping; + ping = pinger.invoke(EFFECTOR_SAY_HI, MutableMap.of()); + Assert.assertEquals(ping.get().trim(), "hello"); + // and check we get the right result + EntityTestUtils.assertAttributeEventually(netcat, SENSOR_OUTPUT_ALL, StringPredicates.containsLiteral("hi netcat")); + log.info("invoked ping from "+pinger+" to "+netcat+", 'all' sensor shows:\n"+ + netcat.getAttribute(SENSOR_OUTPUT_ALL)); + + // netcat should now fail and restart + EntityTestUtils.assertAttributeEventually(netcat, Attributes.SERVICE_STATE_ACTUAL, Predicates.not(Predicates.equalTo(Lifecycle.RUNNING))); + log.info("detected failure, state is: "+netcat.getAttribute(Attributes.SERVICE_STATE_ACTUAL)); + EntityTestUtils.assertAttributeEventually(netcat, Attributes.SERVICE_STATE_ACTUAL, Predicates.equalTo(Lifecycle.RUNNING)); + log.info("detected recovery, state is: "+netcat.getAttribute(Attributes.SERVICE_STATE_ACTUAL)); + + // invoke effector again, now with a parameter + ping = pinger.invoke(EFFECTOR_SAY_HI, MutableMap.of("message", "yo yo yo")); + Assert.assertEquals(ping.get().trim(), "hello"); + // checking right result + EntityTestUtils.assertAttributeEventually(netcat, SENSOR_OUTPUT_ALL, StringPredicates.containsLiteral("yo yo yo")); + log.info("invoked ping again from "+pinger+" to "+netcat+", 'all' sensor shows:\n"+ + netcat.getAttribute(SENSOR_OUTPUT_ALL)); + + // and it's propagated to the app + EntityTestUtils.assertAttributeEventually(app, Sensors.newStringSensor("output.last"), StringPredicates.containsLiteral("yo yo yo")); + + log.info("after all is said and done, app is:"); + Entities.dumpInfo(app); + } + + @Override + protected Logger getLogger() { + return log; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/WrapAppTest.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/WrapAppTest.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/WrapAppTest.java new file mode 100644 index 0000000..e94e8c5 --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/WrapAppTest.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn; + +import java.io.StringReader; + +import org.testng.Assert; +import org.testng.annotations.Test; + +import brooklyn.entity.basic.StartableApplication; + +public class WrapAppTest extends AbstractYamlTest { + private static final String NO_WRAP_APP_IMPLICIT = + "name: Empty App\n" + + "services:\n" + + " - type: brooklyn.test.entity.TestApplication"; + + private static final String NO_WRAP_APP_EXPLICIT = + "name: Empty App\n" + + "wrappedApp: false\n" + + "services:\n" + + " - type: brooklyn.test.entity.TestApplication"; + + private static final String WRAP_APP_IMPLICIT = + "name: Empty App\n" + + "services:\n" + + " - type: brooklyn.test.entity.TestApplication\n" + + " - type: brooklyn.test.entity.TestApplication"; + + private static final String WRAP_APP_EXPLICIT = + "name: Empty App\n" + + "wrappedApp: true\n" + + "services:\n" + + " - type: brooklyn.test.entity.TestApplication"; + + private static final String WRAP_ENTITY = + "name: Empty App\n" + + "services:\n" + + " - type: brooklyn.test.entity.TestEntity"; + + @Test + public void testNoWrapAppImplicit() throws Exception { + StartableApplication app = createApp(NO_WRAP_APP_IMPLICIT); + Assert.assertTrue(app.getChildren().size() == 0); + } + + @Test + public void testNoWrapAppExplicit() throws Exception { + StartableApplication app = createApp(NO_WRAP_APP_EXPLICIT); + Assert.assertTrue(app.getChildren().size() == 0); + } + + @Test + public void testWrapAppImplicit() throws Exception { + StartableApplication app = createApp(WRAP_APP_IMPLICIT); + Assert.assertTrue(app.getChildren().size() == 2); + } + + @Test + public void testWrapAppExplicit() throws Exception { + StartableApplication app = createApp(WRAP_APP_EXPLICIT); + Assert.assertTrue(app.getChildren().size() == 1); + } + + @Test + public void testWrapEntity() throws Exception { + StartableApplication app = createApp(WRAP_ENTITY); + Assert.assertTrue(app.getChildren().size() == 1); + } + + private StartableApplication createApp(String yaml) throws Exception { + StringReader in = new StringReader(yaml); + StartableApplication app = (StartableApplication)createAndStartApplication(in); + in.close(); + return app; + } +} http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/e406d1ad/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/AbstractCatalogXmlTest.java ---------------------------------------------------------------------- diff --git a/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/AbstractCatalogXmlTest.java b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/AbstractCatalogXmlTest.java new file mode 100644 index 0000000..d8675c9 --- /dev/null +++ b/usage/camp/src/test/java/org/apache/brooklyn/camp/brooklyn/catalog/AbstractCatalogXmlTest.java @@ -0,0 +1,109 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.brooklyn.camp.brooklyn.catalog; + +import org.apache.brooklyn.camp.brooklyn.AbstractYamlTest; +import org.apache.brooklyn.test.TestResourceUnavailableException; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.StringReader; + +import brooklyn.config.BrooklynProperties; +import brooklyn.config.BrooklynServerConfig; +import brooklyn.entity.Entity; +import brooklyn.management.internal.LocalManagementContext; +import brooklyn.management.osgi.OsgiTestResources; +import brooklyn.test.entity.LocalManagementContextForTests; +import brooklyn.util.ResourceUtils; +import brooklyn.util.exceptions.Exceptions; +import brooklyn.util.os.Os; +import brooklyn.util.stream.ReaderInputStream; +import brooklyn.util.stream.Streams; + +import com.google.common.io.ByteStreams; + +public class AbstractCatalogXmlTest extends AbstractYamlTest { + + private String catalogUrl; + + public AbstractCatalogXmlTest(String catalogUrl) { + this.catalogUrl = catalogUrl; + } + + @Override + protected LocalManagementContext newTestManagementContext() { + ResourceUtils ru = new ResourceUtils(this); + File jar = createJar(ru); + File catalog = createCatalog(ru, jar); + + BrooklynProperties properties = BrooklynProperties.Factory.newEmpty(); + properties.put(BrooklynServerConfig.BROOKLYN_CATALOG_URL, catalog.toURI().toString()); + return LocalManagementContextForTests.builder(true) + .useProperties(properties) + .disableOsgi(false) + .build(); + } + + protected Entity startApp(String type) throws Exception { + String yaml = "name: simple-app-yaml\n" + + "location: localhost\n" + + "services: \n" + + " - type: " + type; + return createAndStartApplication(yaml); + } + + private File createCatalog(ResourceUtils ru, File tmpJar) { + String catalogTemplate = ru.getResourceAsString(catalogUrl); + String catalog = catalogTemplate.replace("${osgi-entities-path}", tmpJar.toURI().toString()); + File catalogTmp = Os.newTempFile("simple-catalog-", ".xml"); + copy(catalog, catalogTmp); + return catalogTmp; + } + + private File createJar(ResourceUtils ru) { + TestResourceUnavailableException.throwIfResourceUnavailable(getClass(), OsgiTestResources.BROOKLYN_TEST_OSGI_ENTITIES_PATH); + File tmpJar = Os.newTempFile("osgi-entities-", ".jar"); + InputStream in = ru.getResourceFromUrl("classpath://" + OsgiTestResources.BROOKLYN_TEST_OSGI_ENTITIES_PATH); + copy(in, tmpJar); + return tmpJar; + } + + private void copy(String src, File dst) { + try { + copy(new ReaderInputStream(new StringReader(src), "UTF-8"), dst); + } catch (Exception e) { + throw Exceptions.propagate(e); + } + } + + private void copy(InputStream in, File tmpJar) { + try { + OutputStream out = new FileOutputStream(tmpJar); + ByteStreams.copy(in, out); + Streams.closeQuietly(in); + Streams.closeQuietly(out); + } catch (Exception e) { + throw Exceptions.propagate(e); + } + } + +}