/**
   * Applies the given security group permissions to the given node with the given compute service.
   *
   * <p>Takes no action if the compute service does not have a security group extension.
   *
   * @param permissions The set of permissions to be applied to the node
   * @param nodeId The id of the node to update
   * @param computeService The compute service to use to apply the changes
   */
  @VisibleForTesting
  Map<String, SecurityGroup> addPermissionsToLocation(
      Iterable<IpPermission> permissions, final String nodeId, ComputeService computeService) {
    if (!computeService.getSecurityGroupExtension().isPresent()) {
      LOG.warn(
          "Security group extension for {} absent; cannot update node {} with {}",
          new Object[] {computeService, nodeId, permissions});
      return ImmutableMap.of();
    }
    final SecurityGroupExtension securityApi = computeService.getSecurityGroupExtension().get();
    final String locationId = computeService.getContext().unwrap().getId();

    // Expect to have two security groups on the node: one shared between all nodes in the location,
    // that is cached in sharedGroupCache, and one created by Jclouds that is unique to the node.
    // Relies on customize having been called before. This should be safe because the arguments
    // needed to call this method are not available until post-instance creation.
    SecurityGroup machineUniqueSecurityGroup = getSecurityGroup(nodeId, securityApi, locationId);
    MutableList<IpPermission> newPermissions = MutableList.copyOf(permissions);
    Iterables.removeAll(newPermissions, machineUniqueSecurityGroup.getIpPermissions());
    MutableMap<String, SecurityGroup> addedSecurityGroups = MutableMap.of();
    for (IpPermission permission : newPermissions) {
      SecurityGroup addedPermission =
          addPermission(permission, machineUniqueSecurityGroup, securityApi);
      addedSecurityGroups.put(addedPermission.getId(), addedPermission);
    }
    return addedSecurityGroups;
  }
  /** Test that a core can be created and used with SolrJ client. */
  @Test(groups = "Integration")
  public void testConnection() throws Exception {
    solr =
        app.createAndManageChild(
            EntitySpec.create(SolrServer.class)
                .configure(
                    SolrServer.SOLR_CORE_CONFIG,
                    ImmutableMap.of("example", "classpath://solr/example.tgz")));
    app.start(ImmutableList.of(testLocation));

    EntityAsserts.assertAttributeEqualsEventually(solr, Startable.SERVICE_UP, true);

    SolrJSupport client = new SolrJSupport(solr, "example");

    Iterable<SolrDocument> results = client.getDocuments();
    assertTrue(Iterables.isEmpty(results));

    client.addDocument(MutableMap.<String, Object>of("id", "1", "description", "first"));
    client.addDocument(MutableMap.<String, Object>of("id", "2", "description", "second"));
    client.addDocument(MutableMap.<String, Object>of("id", "3", "description", "third"));
    client.commit();

    results = client.getDocuments();
    assertEquals(Iterables.size(results), 3);
  }
 @Test
 public void testAddChildToParentLocationReturnsExpectedLocation() {
   AbstractLocation parent = new ConcreteLocation(MutableMap.of("id", "1"));
   AbstractLocation child = new ConcreteLocation(MutableMap.of("id", "2"));
   parent.addChild(child);
   assertEquals(child.getParent(), parent);
   assertEquals(ImmutableList.copyOf(parent.getChildren()), ImmutableList.of(child));
 }
 @Test
 public void testEquals() {
   AbstractLocation l1 = new ConcreteLocation(MutableMap.of("id", "1", "name", "bob"));
   AbstractLocation l2 = new ConcreteLocation(MutableMap.of("id", "1", "name", "frank"));
   AbstractLocation l3 = new ConcreteLocation(MutableMap.of("id", "2", "name", "frank"));
   assertEquals(l1, l2);
   assertNotEquals(l2, l3);
 }
 @Test
 public void setParentLocationReturnsExpectedLocation() {
   AbstractLocation parent = new ConcreteLocation(MutableMap.of("name", "Middle Earth"));
   AbstractLocation child = new ConcreteLocation(MutableMap.of("name", "The Shire"));
   child.setParent(parent);
   assertEquals(child.getParent(), parent);
   assertEquals(ImmutableList.copyOf(parent.getChildren()), ImmutableList.of(child));
 }
 @Override
 public void stop() {
   newScript(MutableMap.of("usePidFile", false), STOPPING)
       .body
       .append(
           callPgctl(
               (entity.getConfig(PostgreSqlNode.DISCONNECT_ON_STOP) ? "-m immediate " : "")
                   + "stop",
               false))
       .failOnNonZeroResultCode()
       .execute();
   newScript(MutableMap.of("usePidFile", getPidFile(), "processOwner", "postgres"), STOPPING)
       .execute();
 }
 /** error should be json-serializable; exceptions can be problematic */
 protected synchronized void noteErrorObject(Object error) {
   errorMessages.add(
       0, MutableMap.<String, Object>of("error", error, "timestamp", System.currentTimeMillis()));
   while (errorMessages.size() > MAX_ERRORS) {
     errorMessages.remove(errorMessages.size() - 1);
   }
 }
  @Override
  public void doStart(Collection<? extends Location> locs) {
    List<Location> locations = MutableList.of();

    sensors().set(SERVICE_UP, Boolean.FALSE);
    ServiceStateLogic.setExpectedState(this, Lifecycle.STARTING);

    LOG.info("Creating new MesosLocation");
    createLocation(MutableMap.<String, Object>of());

    // Start frameworks
    try {
      Group frameworks = sensors().get(MESOS_FRAMEWORKS);
      Entities.invokeEffectorList(
              this,
              frameworks.getMembers(),
              Startable.START,
              ImmutableMap.of("locations", locations))
          .getUnchecked();
    } catch (Exception e) {
      LOG.warn("Error starting frameworks", e);
      ServiceStateLogic.setExpectedState(this, Lifecycle.ON_FIRE);
      Exceptions.propagate(e);
    }

    super.doStart(locations);

    connectSensors();

    ServiceStateLogic.setExpectedState(this, Lifecycle.RUNNING);
    sensors().set(SERVICE_UP, Boolean.TRUE);
  }
 public static final Optional<String> httpPost(
     Entity framework, String subUrl, String dataUrl, Map<String, Object> substitutions) {
   String targetUrl =
       Urls.mergePaths(framework.sensors().get(MesosFramework.FRAMEWORK_URL), subUrl);
   String templateContents = ResourceUtils.create().getResourceAsString(dataUrl);
   String processedJson =
       TemplateProcessor.processTemplateContents(templateContents, substitutions);
   LOG.debug("Posting JSON to {}: {}", targetUrl, processedJson);
   URI postUri = URI.create(targetUrl);
   HttpToolResponse response =
       HttpTool.httpPost(
           MesosUtils.buildClient(framework),
           postUri,
           MutableMap.of(
               HttpHeaders.CONTENT_TYPE, "application/json",
               HttpHeaders.ACCEPT, "application/json"),
           processedJson.getBytes());
   LOG.debug("Response: " + response.getContentAsString());
   if (!HttpTool.isStatusCodeHealthy(response.getResponseCode())) {
     LOG.warn(
         "Invalid response code {}: {}", response.getResponseCode(), response.getReasonPhrase());
     return Optional.absent();
   } else {
     LOG.debug("Successfull call to {}: {}", targetUrl);
     return Optional.of(response.getContentAsString());
   }
 }
 @Test
 public void queryingNameReturnsNameGivenInConstructor() {
   String name = "Outer Mongolia";
   AbstractLocation location = new ConcreteLocation(MutableMap.of("name", "Outer Mongolia"));
   assertEquals(location.getDisplayName(), name);
   ;
 }
  /**
   * Given an enricher, extracts its state for serialization.
   *
   * @deprecated since 0.7.0, see {@link #newBasicMemento(BrooklynObject)}
   */
  @Deprecated
  public static EnricherMemento newEnricherMemento(Enricher enricher) {
    BasicEnricherMemento.Builder builder = BasicEnricherMemento.builder();
    populateBrooklynObjectMementoBuilder(enricher, builder);

    // TODO persist config keys as well? Or only support those defined on policy class;
    // current code will lose the ConfigKey type on rebind for anything not defined on class.
    // Whereas entities support that.
    // TODO Do we need the "nonPersistableFlagNames" that locations use?
    Map<ConfigKey<?>, Object> config = ((AbstractEnricher) enricher).getConfigMap().getAllConfig();
    for (Map.Entry<ConfigKey<?>, Object> entry : config.entrySet()) {
      ConfigKey<?> key = checkNotNull(entry.getKey(), "config=%s", config);
      Object value = configValueToPersistable(entry.getValue());
      builder.config.put(key.getName(), value);
    }

    Map<String, Object> persistableFlags =
        MutableMap.<String, Object>builder()
            .putAll(
                FlagUtils.getFieldsWithFlagsExcludingModifiers(
                    enricher, Modifier.STATIC ^ Modifier.TRANSIENT))
            .remove("id")
            .remove("name")
            .build();
    builder.config.putAll(persistableFlags);

    return builder.build();
  }
 public static Map<String, Object> getSensorMap(String sensor, Iterable<Entity> descs) {
   if (Iterables.isEmpty(descs)) return Collections.emptyMap();
   Map<String, Object> result = MutableMap.of();
   Iterator<Entity> di = descs.iterator();
   Sensor<?> s = null;
   while (di.hasNext()) {
     Entity potentialSource = di.next();
     s = potentialSource.getEntityType().getSensor(sensor);
     if (s != null) break;
   }
   if (s == null) s = Sensors.newSensor(Object.class, sensor);
   if (!(s instanceof AttributeSensor<?>)) {
     log.warn("Cannot retrieve non-attribute sensor " + s + " for entities; returning empty map");
     return result;
   }
   for (Entity e : descs) {
     Object v = null;
     try {
       v = e.getAttribute((AttributeSensor<?>) s);
     } catch (Exception exc) {
       Exceptions.propagateIfFatal(exc);
       log.warn("Error retrieving sensor " + s + " for " + e + " (ignoring): " + exc);
     }
     if (v != null) result.put(e.getId(), v);
   }
   return result;
 }
  /**
   * Method which returns a Future containing a string formatted using String.format, where the
   * arguments can be normal objects or tasks; tasks will be waited on (submitted if necessary) and
   * their results substituted in the call to String.format.
   *
   * <p>Example:
   *
   * <pre>{@code
   * setConfig(URL, DependentConfiguration.formatString("%s:%s",
   *         DependentConfiguration.attributeWhenReady(target, Target.HOSTNAME),
   *         DependentConfiguration.attributeWhenReady(target, Target.PORT) ) );
   * }</pre>
   */
  @SuppressWarnings("unchecked")
  public static Task<String> formatString(final String spec, final Object... args) {
    List<TaskAdaptable<Object>> taskArgs = Lists.newArrayList();
    for (Object arg : args) {
      if (arg instanceof TaskAdaptable) taskArgs.add((TaskAdaptable<Object>) arg);
      else if (arg instanceof TaskFactory)
        taskArgs.add(((TaskFactory<TaskAdaptable<Object>>) arg).newTask());
    }

    return transformMultiple(
        MutableMap.<String, String>of(
            "displayName",
            "formatting '"
                + spec
                + "' with "
                + taskArgs.size()
                + " task"
                + (taskArgs.size() != 1 ? "s" : "")),
        new Function<List<Object>, String>() {
          @Override
          public String apply(List<Object> input) {
            Iterator<?> tri = input.iterator();
            Object[] vv = new Object[args.length];
            int i = 0;
            for (Object arg : args) {
              if (arg instanceof TaskAdaptable || arg instanceof TaskFactory) vv[i] = tri.next();
              else if (arg instanceof DeferredSupplier) vv[i] = ((DeferredSupplier<?>) arg).get();
              else vv[i] = arg;
              i++;
            }
            return String.format(spec, vv);
          }
        },
        taskArgs);
  }
 @Override
 public Map<String, String> getShellEnvironment() {
   return MutableMap.<String, String>builder()
       .putAll(super.getShellEnvironment())
       .put("PORT", Integer.toString(getHttpPort()))
       .build();
 }
 @Test
 public void nullNameAndParentLocationIsAcceptable() {
   AbstractLocation location =
       new ConcreteLocation(MutableMap.of("name", null, "parentLocation", null));
   assertEquals(location.getDisplayName(), null);
   assertEquals(location.getParent(), null);
 }
  @Override
  public void init() {
    super.init();

    ConfigToAttributes.apply(this, DOCKER_HOST);
    ConfigToAttributes.apply(this, DOCKER_REGISTRY_PORT);

    DockerHost host = (DockerHost) sensors().get(DOCKER_HOST);
    String installDir = host.sensors().get(SoftwareProcess.INSTALL_DIR);
    SshMachineLocation sshMachine = host.getDynamicLocation().getMachine();
    String sshMachineInstallDir = getSSHMachineInstallDir();

    config()
        .set(
            DockerAttributes.DOCKER_PORT_BINDINGS,
            MutableMap.of(sensors().get(DOCKER_REGISTRY_PORT), 5000));
    config()
        .set(
            DockerAttributes.DOCKER_HOST_VOLUME_MAPPING,
            MutableMap.of(Os.mergePaths(installDir, "certs"), "/certs"));

    sshMachine.installTo(
        ImmutableMap.of(SshTool.PROP_PERMISSIONS.getName(), "0755"),
        SCRIPT_LOCATION,
        Os.mergePaths(sshMachineInstallDir, CREATE_CERTS_SCRIPT_NAME));
    sshMachine.installTo(
        config().get(DockerInfrastructure.DOCKER_CA_CERTIFICATE_PATH),
        Os.mergePaths(sshMachineInstallDir, "ca-cert.pem"));
    sshMachine.installTo(
        config().get(DockerInfrastructure.DOCKER_CA_KEY_PATH),
        Os.mergePaths(sshMachineInstallDir, "ca-key.pem"));

    int result =
        sshMachine.execCommands(
            "installCerts",
            ImmutableList.of(
                BashCommands.sudo(
                    String.format(
                        "%s %s %s",
                        Os.mergePaths(sshMachineInstallDir, CREATE_CERTS_SCRIPT_NAME),
                        host.sensors().get(Attributes.ADDRESS),
                        sshMachineInstallDir))));
    if (result != 0) {
      throw new IllegalStateException("Could not create certificates for docker registry");
    }
  }
 @Override
 public boolean isRunning() {
   return newScript(MutableMap.of("usePidFile", getPidFile()), CHECK_RUNNING)
           .body
           .append(getStatusCmd())
           .execute()
       == 0;
 }
 @Override
 public void launch() {
   log.info(String.format("Starting entity %s at %s", this, getLocation()));
   newScript(MutableMap.of("usePidFile", false), LAUNCHING)
       .body
       .append(callPgctl("start", false))
       .execute();
 }
 protected Map<String, Object> obtainProvisioningFlags(
     final MachineProvisioningLocation<?> location) {
   if (entity() instanceof ProvidesProvisioningFlags) {
     return ((ProvidesProvisioningFlags) entity())
         .obtainProvisioningFlags(location)
         .getAllConfig();
   }
   return MutableMap.<String, Object>of();
 }
 @Override
 public Map<String, BrooklynObject> getAllBrooklynObjects() {
   MutableMap<String, BrooklynObject> result = MutableMap.of();
   result.putAll(locations);
   result.putAll(entities);
   result.putAll(policies);
   result.putAll(enrichers);
   result.putAll(feeds);
   result.putAll(catalogItems);
   return result.asUnmodifiable();
 }
 protected void runTest(Map<String, ?> flags) throws Exception {
   String tag = getClass().getSimpleName().toLowerCase();
   Map<String, ?> allFlags =
       MutableMap.<String, Object>builder()
           .put("tags", ImmutableList.of(tag))
           .putAll(flags)
           .build();
   jcloudsLocation = ctx.getLocationRegistry().getLocationManaged(PROVIDER, allFlags);
   doTest(jcloudsLocation);
 }
  @Override
  public Map<String, Object> getMetrics() {
    Map<String, Object> result = MutableMap.of();

    result.put("rebind", rebindMetrics.asMap());
    result.put("persist", persistMetrics.asMap());

    if (readOnlyRebindCount.get() >= 0) result.put("rebindReadOnlyCount", readOnlyRebindCount);

    // include first rebind counts, so we know whether we rebinded or not
    result.put(
        "firstRebindCounts",
        MutableMap.of(
            "applications", firstRebindAppCount,
            "entities", firstRebindEntityCount,
            "allItems", firstRebindItemCount));

    return result;
  }
 public static Task<String> regexReplacement(Object source, Object pattern, Object replacement) {
   List<TaskAdaptable<Object>> taskArgs = getTaskAdaptable(source, pattern, replacement);
   Function<List<Object>, String> transformer =
       new RegexTransformerString(source, pattern, replacement);
   return transformMultiple(
       MutableMap.of(
           "displayName",
           String.format("creating regex replacement function (%s:%s)", pattern, replacement)),
       transformer,
       taskArgs);
 }
 @Override
 public void stop() {
   String customCommand = getEntity().getConfig(VanillaSoftwareProcess.STOP_COMMAND);
   ScriptHelper script = null;
   if (customCommand == null) {
     script = newScript(MutableMap.of(USE_PID_FILE, getPidFile()), STOPPING);
   } else {
     // TODO: template substitutions?
     script = newScript(STOPPING).body.append(customCommand);
   }
   script.execute();
 }
 @Override
 public boolean isRunning() {
   String customCommand = getEntity().getConfig(VanillaSoftwareProcess.CHECK_RUNNING_COMMAND);
   ScriptHelper script = null;
   if (customCommand == null) {
     script = newScript(MutableMap.of(USE_PID_FILE, getPidFile()), CHECK_RUNNING);
   } else {
     // TODO: template substitutions?
     script = newScript(CHECK_RUNNING).body.append(customCommand);
   }
   return script.execute() == 0;
 }
  @Test
  public void testCustomAttrs() throws IOException {
    LinkDto l = LinkDto.newInstance("http://foo", "Foo", MutableMap.of("bar", "bee"));

    JsonNode t = BasicDtoTest.tree(l);
    Assert.assertEquals(t.size(), 3);
    Assert.assertEquals(t.get("href").asText(), l.getHref());
    Assert.assertEquals(t.get("targetName").asText(), l.getTargetName());
    Assert.assertEquals(t.get("bar").asText(), l.getCustomAttributes().get("bar"));

    Assert.assertEquals(l, new ObjectMapper().readValue(t.toString(), LinkDto.class));
  }
 public synchronized Map<String, Object> asMap() {
   Map<String, Object> result = MutableMap.of();
   result.put("count", count);
   result.put("lastSuccessTimeUtc", lastSuccessTime);
   result.put("lastSuccessTimeMillisSince", since(lastSuccessTime));
   result.put("lastDuration", lastDuration);
   result.put("failureCount", failureCount);
   result.put("lastFailureTimeUtc", lastFailureTime);
   result.put("lastFailureTimeMillisSince", since(lastFailureTime));
   result.put("errorMessages", MutableList.copyOf(errorMessages));
   return result;
 }
 private void assertHasEventEventually(
     final Sensor<?> sensor,
     final Predicate<Object> componentPredicate,
     final Predicate<? super CharSequence> descriptionPredicate) {
   Asserts.succeedsEventually(
       MutableMap.of("timeout", TIMEOUT_MS),
       new Runnable() {
         @Override
         public void run() {
           assertHasEvent(sensor, componentPredicate, descriptionPredicate);
         }
       });
 }
  private Map<String, Object> getExtraTemplateSubstitutions(String imageName, Entity context) {
    Map<String, Object> templateSubstitutions =
        MutableMap.<String, Object>of("fullyQualifiedImageName", imageName);
    templateSubstitutions.putAll(
        getOwner().config().get(DockerInfrastructure.DOCKERFILE_SUBSTITUTIONS));

    // Add any extra substitutions on the entity (if present)
    if (context != null) {
      templateSubstitutions.putAll(
          context.config().get(DockerInfrastructure.DOCKERFILE_SUBSTITUTIONS));
    }

    return templateSubstitutions;
  }
  /** @deprecated since 0.7.0; use {@link #newBasicMemento(BrooklynObject)} instead */
  @Deprecated
  public static BasicLocationMemento.Builder newLocationMementoBuilder(Location location) {
    BasicLocationMemento.Builder builder = BasicLocationMemento.builder();
    populateBrooklynObjectMementoBuilder(location, builder);

    Set<String> nonPersistableFlagNames =
        MutableMap.<String, Object>builder()
            .putAll(FlagUtils.getFieldsWithFlagsWithModifiers(location, Modifier.TRANSIENT))
            .putAll(FlagUtils.getFieldsWithFlagsWithModifiers(location, Modifier.STATIC))
            .put("id", String.class)
            .filterValues(Predicates.not(Predicates.instanceOf(ConfigKey.class)))
            .build()
            .keySet();
    Map<String, Object> persistableFlags =
        MutableMap.<String, Object>builder()
            .putAll(
                FlagUtils.getFieldsWithFlagsExcludingModifiers(
                    location, Modifier.STATIC ^ Modifier.TRANSIENT))
            .removeAll(nonPersistableFlagNames)
            .build();
    ConfigBag persistableConfig =
        new ConfigBag()
            .copy(((LocationInternal) location).config().getLocalBag())
            .removeAll(nonPersistableFlagNames);

    builder.copyConfig(persistableConfig);
    builder.locationConfig.putAll(persistableFlags);

    Location parentLocation = location.getParent();
    builder.parent = (parentLocation != null) ? parentLocation.getId() : null;

    for (Location child : location.getChildren()) {
      builder.children.add(child.getId());
    }

    return builder;
  }