Esempio n. 1
0
 @Test
 public void testCreateRespectsConfigKey() {
   TestEntity entity2 =
       app.createAndManageChild(
           TestEntity.Spec.newInstance().configure(TestEntity.CONF_NAME, "foo"));
   assertEquals(entity2.getConfig(TestEntity.CONF_NAME), "foo");
 }
  @Test
  public void testServiceReplacerWorksAfterRebind() throws Exception {
    Location origLoc =
        origManagementContext
            .getLocationManager()
            .createLocation(LocationSpec.create(SimulatedLocation.class));
    DynamicCluster origCluster =
        origApp.createAndManageChild(
            EntitySpec.create(DynamicCluster.class)
                .configure(DynamicCluster.MEMBER_SPEC, EntitySpec.create(TestEntity.class))
                .configure(DynamicCluster.INITIAL_SIZE, 3));
    origApp.start(ImmutableList.<Location>of(origLoc));

    origCluster.addPolicy(
        PolicySpec.create(ServiceReplacer.class)
            .configure(ServiceReplacer.FAILURE_SENSOR_TO_MONITOR, HASensors.ENTITY_FAILED));

    // rebind
    TestApplication newApp = rebind();
    final DynamicCluster newCluster =
        (DynamicCluster)
            Iterables.find(newApp.getChildren(), Predicates.instanceOf(DynamicCluster.class));

    // stimulate the policy
    final Set<Entity> initialMembers = ImmutableSet.copyOf(newCluster.getMembers());
    final TestEntity e1 = (TestEntity) Iterables.get(initialMembers, 1);

    newApp
        .getManagementContext()
        .getSubscriptionManager()
        .subscribe(e1, HASensors.ENTITY_FAILED, eventListener);
    newApp
        .getManagementContext()
        .getSubscriptionManager()
        .subscribe(e1, HASensors.ENTITY_RECOVERED, eventListener);

    e1.emit(HASensors.ENTITY_FAILED, new FailureDescriptor(e1, "simulate failure"));

    // Expect e1 to be replaced
    Asserts.succeedsEventually(
        new Runnable() {
          @Override
          public void run() {
            Set<Entity> newMembers =
                Sets.difference(ImmutableSet.copyOf(newCluster.getMembers()), initialMembers);
            Set<Entity> removedMembers =
                Sets.difference(initialMembers, ImmutableSet.copyOf(newCluster.getMembers()));
            assertEquals(removedMembers, ImmutableSet.of(e1));
            assertEquals(newMembers.size(), 1);
            assertEquals(
                ((TestEntity) Iterables.getOnlyElement(newMembers)).getCallHistory(),
                ImmutableList.of("start"));

            // TODO e1 not reporting "start" after rebind because callHistory is a field rather than
            // an attribute, so was not persisted
            Asserts.assertEqualsIgnoringOrder(e1.getCallHistory(), ImmutableList.of("stop"));
            assertFalse(Entities.isManaged(e1));
          }
        });
  }
Esempio n. 3
0
 @Test
 public void testDisplayName() {
   TestEntity result =
       entity.createAndManageChild(TestEntity.Spec.newInstance().displayName("Boo"));
   assertIsProxy(result);
   assertEquals(result.getDisplayName(), "Boo");
 }
  @Test
  public void testUnsubscribeRemovesAllSubscriptionsForThatEntity() throws Exception {
    policy.subscribe(entity, TestEntity.SEQUENCE, listener);
    policy.subscribe(entity, TestEntity.NAME, listener);
    policy.subscribe(entity, TestEntity.MY_NOTIF, listener);
    policy.subscribe(otherEntity, TestEntity.SEQUENCE, listener);
    policy.unsubscribe(entity);

    entity.setAttribute(TestEntity.SEQUENCE, 123);
    entity.setAttribute(TestEntity.NAME, "myname");
    entity.emit(TestEntity.MY_NOTIF, 456);
    otherEntity.setAttribute(TestEntity.SEQUENCE, 789);

    Thread.sleep(SHORT_WAIT_MS);
    Asserts.succeedsEventually(
        new Runnable() {
          @Override
          public void run() {
            assertEquals(
                listener.events,
                ImmutableList.of(
                    new BasicSensorEvent<Integer>(TestEntity.SEQUENCE, otherEntity, 789)));
          }
        });
  }
Esempio n. 5
0
 @Test
 public void testCreateRespectsFlagInMap() {
   TestEntity entity2 =
       app.createAndManageChild(
           TestEntity.Spec.newInstance().configure(MutableMap.of("confName", "baz")));
   assertEquals(entity2.getConfig(TestEntity.CONF_NAME), "baz");
 }
 @Test
 public void testGetEffector() throws Exception {
   TestEntity entity2 = app.createAndManageChild(EntitySpecs.spec(TestEntity.class));
   Effector<?> effector = entity2.getEntityType().getEffector("myEffector");
   Effector<?> effector2 = entity2.getEntityType().getEffector("identityEffector", Object.class);
   assertEquals(effector.getName(), "myEffector");
   assertEquals(effector2.getName(), "identityEffector");
 }
Esempio n. 7
0
 @Test
 public void testCreateAndManageChild() {
   TestEntity result = entity.createAndManageChild(TestEntity.Spec.newInstance());
   assertIsProxy(result);
   assertIsProxy(Iterables.get(entity.getChildren(), 0));
   assertIsProxy(result.getParent());
   assertIsProxy(managementContext.getEntityManager().getEntity(result.getId()));
 }
Esempio n. 8
0
  @Test
  public void testGetChildrenAndParentsReturnsProxies() {
    TestEntity child = (TestEntity) Iterables.get(app.getChildren(), 0);
    Application parent = (Application) child.getParent();

    assertIsProxy(child);
    assertIsProxy(parent);
  }
  @Test
  public void testRestoresSetConfigKey() throws Exception {
    origApp.createAndManageChild(
        EntitySpec.create(TestEntity.class)
            .configure(TestEntity.CONF_SET_THING.subKey(), "val1")
            .configure(TestEntity.CONF_SET_THING.subKey(), "val2"));

    newApp = rebind();
    final TestEntity newE =
        (TestEntity) Iterables.find(newApp.getChildren(), Predicates.instanceOf(TestEntity.class));

    assertEquals(newE.getConfig(TestEntity.CONF_SET_THING), ImmutableSet.of("val1", "val2"));
  }
  @Test(groups = "Integration")
  public void testPollsUrl() throws Exception {
    entity.setAttribute(TestEntity.SERVICE_UP, true);

    entity.addEnricher(
        HttpLatencyDetector.builder()
            .url(baseUrl)
            .rollup(500, TimeUnit.MILLISECONDS)
            .period(100, TimeUnit.MILLISECONDS)
            .build());

    assertLatencyAttributesNonNull(entity);
  }
  @Test(groups = "Integration")
  public void testGetsSensorIfAlredySetThenPolls() throws Exception {
    entity.setAttribute(TEST_URL, baseUrl.toString());

    entity.addEnricher(
        HttpLatencyDetector.builder()
            .url(TEST_URL)
            .noServiceUp()
            .rollup(500, TimeUnit.MILLISECONDS)
            .period(100, TimeUnit.MILLISECONDS)
            .build());

    assertLatencyAttributesNonNull(entity);
  }
  @Test
  public void testRestoresConfigKeys() throws Exception {
    origApp.createAndManageChild(
        EntitySpec.create(TestEntity.class)
            .configure(TestEntity.CONF_NAME, "nameval")
            .configure(TestEntity.CONF_LIST_PLAIN, ImmutableList.of("val1", "val2"))
            .configure(TestEntity.CONF_MAP_PLAIN, ImmutableMap.of("akey", "aval")));

    newApp = rebind();
    final TestEntity newE =
        (TestEntity) Iterables.find(newApp.getChildren(), Predicates.instanceOf(TestEntity.class));

    assertEquals(newE.getConfig(TestEntity.CONF_NAME), "nameval");
    assertEquals(newE.getConfig(TestEntity.CONF_LIST_PLAIN), ImmutableList.of("val1", "val2"));
    assertEquals(newE.getConfig(TestEntity.CONF_MAP_PLAIN), ImmutableMap.of("akey", "aval"));
  }
  @Test // ListConfigKey deprecated, as order no longer guaranteed
  public void testRestoresListConfigKey() throws Exception {
    origApp.createAndManageChild(
        EntitySpec.create(TestEntity.class)
            .configure(TestEntity.CONF_LIST_THING.subKey(), "val1")
            .configure(TestEntity.CONF_LIST_THING.subKey(), "val2"));

    newApp = rebind();
    final TestEntity newE =
        (TestEntity) Iterables.find(newApp.getChildren(), Predicates.instanceOf(TestEntity.class));

    // assertEquals(newE.getConfig(TestEntity.CONF_LIST_THING), ImmutableList.of("val1", "val2"));
    assertEquals(
        ImmutableSet.copyOf(newE.getConfig(TestEntity.CONF_LIST_THING)),
        ImmutableSet.of("val1", "val2"));
  }
  @Test
  public void testEscapesUriForSensorName() throws IOException {
    Sensor<String> sensor = Sensors.newStringSensor("name with space");
    SensorSummary summary = SensorTransformer.sensorSummary(entity, sensor);
    URI selfUri = summary.getLinks().get("self");

    String expectedUri =
        "/v1/applications/"
            + entity.getApplicationId()
            + "/entities/"
            + entity.getId()
            + "/sensors/"
            + "name%20with%20space";

    assertEquals(selfUri, URI.create(expectedUri));
  }
 @Test
 public void testSubstitutionUsesDriverBean() throws Exception {
   String entityid = entity.getId();
   String pattern = "id=${driver.entity.id}";
   BasicDownloadRequirement req = new BasicDownloadRequirement(driver);
   String result = DownloadSubstituters.substitute(req, pattern);
   assertEquals(result, String.format("id=%s", entityid));
 }
  @Test(groups = "Integration")
  public void testWaitsForServiceUp() throws Exception {
    entity.setAttribute(TestEntity.SERVICE_UP, false);

    entity.addEnricher(
        HttpLatencyDetector.builder().url(baseUrl).period(100, TimeUnit.MILLISECONDS).build());

    // nothing until url is set
    EntityTestUtils.assertAttributeEqualsContinually(
        MutableMap.of("timeout", 200),
        entity,
        HttpLatencyDetector.REQUEST_LATENCY_IN_SECONDS_MOST_RECENT,
        null);

    // gets value after url is set, and gets rolling average
    entity.setAttribute(TestEntity.SERVICE_UP, true);
    assertLatencyAttributesNonNull(entity);
  }
  @Test
  public void testInvokeStopEntityOnShutdown() throws Exception {
    BrooklynShutdownHooks.invokeStopOnShutdown(entity);
    BrooklynShutdownHooks.BrooklynShutdownHookJob job =
        BrooklynShutdownHookJob.newInstanceForTesting();
    job.run();

    assertTrue(entity.getCallHistory().contains("stop"));
  }
 @Test
 public void testSimpleSubstitution() throws Exception {
   entity.setConfig(BrooklynConfigKeys.SUGGESTED_VERSION, "myversion");
   String pattern = "mykey1=${mykey1},mykey2=${mykey2}";
   String result =
       DownloadSubstituters.substitute(
           pattern, ImmutableMap.of("mykey1", "myval1", "mykey2", "myval2"));
   assertEquals(result, "mykey1=myval1,mykey2=myval2");
 }
 @Test
 public void testSubstitutionUsesOverrides() throws Exception {
   entity.setConfig(BrooklynConfigKeys.SUGGESTED_VERSION, "myversion");
   String pattern = "version=${version},mykey1=${mykey1}";
   BasicDownloadRequirement req =
       new BasicDownloadRequirement(
           driver, ImmutableMap.of("version", "overriddenversion", "mykey1", "myval1"));
   String result = DownloadSubstituters.substitute(req, pattern);
   assertEquals(result, "version=overriddenversion,mykey1=myval1");
 }
  // Should first stop entities, then terminate management contexts
  @Test
  public void testInvokeStopEntityAndTerminateManagementContextOnShutdown() throws Exception {
    BrooklynShutdownHooks.invokeTerminateOnShutdown(managementContext);
    BrooklynShutdownHooks.invokeStopOnShutdown(entity);
    BrooklynShutdownHooks.BrooklynShutdownHookJob job =
        BrooklynShutdownHookJob.newInstanceForTesting();
    job.run();

    assertTrue(entity.getCallHistory().contains("stop"));
    assertFalse(managementContext.isRunning());
  }
  // Previously failed because immutable-map builder threw exception if put same key multiple times,
  // and the NamedActionWithUrl did not have equals/hashCode
  @Test
  public void testSensorWithMultipleOpenUrlActionsRegistered() throws IOException {
    AttributeSensor<String> sensor = Sensors.newStringSensor("sensor1");
    entity.setAttribute(sensor, "http://myval");
    RendererHints.register(sensor, RendererHints.namedActionWithUrl());
    RendererHints.register(sensor, RendererHints.namedActionWithUrl());

    SensorSummary summary = SensorTransformer.sensorSummary(entity, sensor);

    assertEquals(summary.getLinks().get("action:open"), URI.create("http://myval"));
  }
  @Test
  public void testServiceRestarterWorksAfterRebind() throws Exception {
    origEntity.addPolicy(
        PolicySpec.create(ServiceRestarter.class)
            .configure(ServiceRestarter.FAILURE_SENSOR_TO_MONITOR, HASensors.ENTITY_FAILED));

    TestApplication newApp = rebind();
    final TestEntity newEntity =
        (TestEntity) Iterables.find(newApp.getChildren(), Predicates.instanceOf(TestEntity.class));

    newEntity.emit(HASensors.ENTITY_FAILED, new FailureDescriptor(origEntity, "simulate failure"));

    Asserts.succeedsEventually(
        new Runnable() {
          @Override
          public void run() {
            assertEquals(newEntity.getCallHistory(), ImmutableList.of("restart"));
          }
        });
  }
 @Test
 public void testSubstitutionIncludesDefaultSubs() throws Exception {
   entity.setConfig(BrooklynConfigKeys.SUGGESTED_VERSION, "myversion");
   String pattern = "version=${version},type=${type},simpletype=${simpletype}";
   BasicDownloadRequirement req = new BasicDownloadRequirement(driver);
   String result = DownloadSubstituters.substitute(req, pattern);
   assertEquals(
       result,
       String.format(
           "version=%s,type=%s,simpletype=%s",
           "myversion", TestEntity.class.getName(), TestEntity.class.getSimpleName()));
 }
  @Test
  public void testGetEffectors() throws Exception {
    TestEntity entity2 = app.createAndManageChild(EntitySpecs.spec(TestEntity.class));
    Set<Effector<?>> effectors = entity2.getEntityType().getEffectors();

    class MatchesNamePredicate implements Predicate<Effector<?>> {
      private final String name;

      public MatchesNamePredicate(String name) {
        this.name = name;
      }

      @Override
      public boolean apply(@Nullable Effector<?> input) {
        return name.equals(input.getName());
      }
    };

    assertNotNull(Iterables.find(effectors, new MatchesNamePredicate("myEffector")), null);
    assertNotNull(Iterables.find(effectors, new MatchesNamePredicate("identityEffector")), null);
  }
 @BeforeMethod(alwaysRun = true)
 @Override
 public void setUp() throws Exception {
   super.setUp();
   loc = app.newSimulatedLocation();
   entity = app.createAndManageChild(EntitySpec.create(TestEntity.class));
   otherEntity = app.createAndManageChild(EntitySpec.create(TestEntity.class));
   listener = new RecordingSensorEventListener();
   policy = new AbstractPolicy() {};
   entity.addPolicy(policy);
   app.start(ImmutableList.of(loc));
 }
Esempio n. 26
0
  @Test
  public void testEffectorOnProxyIsRecorded() {
    Object result = entity.identityEffector("abc");
    assertEquals(result, "abc");

    Set<Task<?>> tasks =
        managementContext
            .getExecutionManager()
            .getTasksWithAllTags(ImmutableList.of(ManagementContextInternal.EFFECTOR_TAG, entity));
    Task<?> task = Iterables.get(tasks, 0);
    assertEquals(tasks.size(), 1, "tasks=" + tasks);
    assertTrue(task.getDescription().contains("identityEffector"));
  }
 @Test
 public void testSubstituter() throws Exception {
   entity.setConfig(BrooklynConfigKeys.SUGGESTED_VERSION, "myversion");
   String baseurl = "version=${version},type=${type},simpletype=${simpletype}";
   Map<String, Object> subs = DownloadSubstituters.getBasicEntitySubstitutions(driver);
   DownloadTargets result =
       DownloadSubstituters.substituter(Functions.constant(baseurl), Functions.constant(subs))
           .apply(new BasicDownloadRequirement(driver));
   String expected =
       String.format(
           "version=%s,type=%s,simpletype=%s",
           "myversion", TestEntity.class.getName(), TestEntity.class.getSimpleName());
   assertEquals(result.getPrimaryLocations(), ImmutableList.of(expected));
 }
  @Test
  public void testServiceFailureDetectorWorksAfterRebind() throws Exception {
    origEntity.addEnricher(EnricherSpec.create(ServiceFailureDetector.class));

    // rebind
    TestApplication newApp = rebind();
    final TestEntity newEntity =
        (TestEntity) Iterables.find(newApp.getChildren(), Predicates.instanceOf(TestEntity.class));

    newApp
        .getManagementContext()
        .getSubscriptionManager()
        .subscribe(newEntity, HASensors.ENTITY_FAILED, eventListener);

    newEntity.setAttribute(TestEntity.SERVICE_UP, true);
    ServiceStateLogic.setExpectedState(newEntity, Lifecycle.RUNNING);

    // trigger the failure
    newEntity.setAttribute(TestEntity.SERVICE_UP, false);

    assertHasEventEventually(HASensors.ENTITY_FAILED, Predicates.<Object>equalTo(newEntity), null);
    assertEquals(events.size(), 1, "events=" + events);
  }
  @Test
  public void testRestoresUnmatchedConfig() throws Exception {
    TestEntity origE =
        origApp.createAndManageChild(
            EntitySpec.create(TestEntity.class).configure("myunmatchedkey", "myunmatchedval"));

    origE.createAndManageChild(EntitySpec.create(TestEntity.class));

    newApp = rebind();
    final TestEntity newE =
        (TestEntity) Iterables.find(newApp.getChildren(), Predicates.instanceOf(TestEntity.class));
    final TestEntity newChildE =
        (TestEntity) Iterables.find(newE.getChildren(), Predicates.instanceOf(TestEntity.class));

    assertEquals(newE.getAllConfigBag().getStringKey("myunmatchedkey"), "myunmatchedval");
    assertEquals(newE.getLocalConfigBag().getStringKey("myunmatchedkey"), "myunmatchedval");

    assertEquals(newChildE.getAllConfigBag().getStringKey("myunmatchedkey"), "myunmatchedval");
    assertFalse(newChildE.getLocalConfigBag().containsKey("myunmatchedkey"));
  }
  @Test
  public void testSubscriptionReceivesEvents() throws Exception {
    policy.subscribe(entity, TestEntity.SEQUENCE, listener);
    policy.subscribe(entity, TestEntity.NAME, listener);
    policy.subscribe(entity, TestEntity.MY_NOTIF, listener);

    otherEntity.setAttribute(TestEntity.SEQUENCE, 456);
    entity.setAttribute(TestEntity.SEQUENCE, 123);
    entity.setAttribute(TestEntity.NAME, "myname");
    entity.emit(TestEntity.MY_NOTIF, 789);

    Asserts.succeedsEventually(
        new Runnable() {
          @Override
          public void run() {
            assertEquals(
                listener.events,
                ImmutableList.of(
                    new BasicSensorEvent<Integer>(TestEntity.SEQUENCE, entity, 123),
                    new BasicSensorEvent<String>(TestEntity.NAME, entity, "myname"),
                    new BasicSensorEvent<Integer>(TestEntity.MY_NOTIF, entity, 789)));
          }
        });
  }