private void filterNot(Properties properties, @Nullable List<String> exclusions) {
    if (exclusions == null) return;

    List<Predicate<CharSequence>> excludePredicates =
        Lists.transform(
            exclusions,
            new Function<String, Predicate<CharSequence>>() {
              @Override
              public Predicate<CharSequence> apply(String exclude) {
                return Predicates.containsPattern(exclude);
              }
            });

    Predicate<CharSequence> shouldExclude = Predicates.alwaysFalse();
    for (Predicate<CharSequence> predicate : excludePredicates) {
      shouldExclude = Predicates.or(shouldExclude, predicate);
    }

    for (String key : properties.stringPropertyNames()) {
      if (shouldExclude.apply(key)) {
        loggerBridge.debug("shouldExclude.apply(" + key + ") = " + shouldExclude.apply(key));
        properties.remove(key);
      }
    }
  }
 /** {@inheritDoc} */
 @Override
 public void destroyLoadBalancer(final String id) {
   checkNotNull(id, "id");
   logger.debug(">> destroying load balancer(%s)", id);
   final AtomicReference<LoadBalancerMetadata> loadBalancer = Atomics.newReference();
   Predicate<String> tester =
       retry(
           new Predicate<String>() {
             public boolean apply(String input) {
               try {
                 LoadBalancerMetadata md = destroyLoadBalancerStrategy.destroyLoadBalancer(id);
                 if (md != null) loadBalancer.set(md);
                 return true;
               } catch (IllegalStateException e) {
                 logger.warn("<< illegal state destroying load balancer(%s)", id);
                 return false;
               }
             }
           },
           3000,
           1000,
           MILLISECONDS); // TODO make timeouts class like ComputeServiceconstants
   boolean successful = tester.apply(id) && loadBalancer.get() == null; // TODO add load
   // balancerTerminated
   // retryable predicate
   // (load balancer.get() == null ||
   // load balancerTerminated.apply(load balancer.get()));
   logger.debug("<< destroyed load balancer(%s) success(%s)", id, successful);
 }
Example #3
0
  protected void scan(URL url) {
    Vfs.Dir dir = Vfs.fromURL(url);

    try {
      for (final Vfs.File file : dir.getFiles()) {
        // scan if inputs filter accepts file relative path or fqn
        Predicate<String> inputsFilter = configuration.getInputsFilter();
        String path = file.getRelativePath();
        String fqn = path.replace('/', '.');
        if (inputsFilter == null || inputsFilter.apply(path) || inputsFilter.apply(fqn)) {
          Object classObject = null;
          for (Scanner scanner : configuration.getScanners()) {
            try {
              if (scanner.acceptsInput(path) || scanner.acceptResult(fqn)) {
                classObject = scanner.scan(file, classObject);
              }
            } catch (Exception e) {
              if (log != null && log.isDebugEnabled())
                log.debug(
                    "could not scan file "
                        + file.getRelativePath()
                        + " in url "
                        + url.toExternalForm()
                        + " with scanner "
                        + scanner.getClass().getSimpleName(),
                    e);
            }
          }
        }
      }
    } finally {
      dir.close();
    }
  }
 public Intent fromUri(URI uri) {
   uri = resolveUri(uri);
   Intent intent = new Intent("android.intent.action.VIEW", uri);
   Iterator iterator = conditionalComponentNameMap.keySet().iterator();
   do {
     if (!iterator.hasNext()) {
       break;
     }
     Predicate predicate = (Predicate) iterator.next();
     if (predicate.apply(uri)) {
       intent.setComponent((ComponentName) conditionalComponentNameMap.get(predicate));
     }
   } while (true);
   iterator = conditionalPackageNameMap.keySet().iterator();
   do {
     if (!iterator.hasNext()) {
       break;
     }
     Predicate predicate1 = (Predicate) iterator.next();
     if (predicate1.apply(uri)) {
       intent.setPackage((String) conditionalPackageNameMap.get(predicate1));
     }
   } while (true);
   return intent;
 }
  @Test
  public void apply_returns_false_for_String_measure() {
    Predicate<Measure> underTest =
        BestValueOptimization.from(createMetric(Metric.MetricType.FLOAT, 36.5d), FILE_COMPONENT);

    assertThat(underTest.apply(newMeasureBuilder().create("aaa"))).isFalse();
  }
  @Test
  public void apply_returns_false_for_LEVEL_measure() {
    Predicate<Measure> underTest =
        BestValueOptimization.from(createMetric(Metric.MetricType.STRING, 36.5d), FILE_COMPONENT);

    assertThat(underTest.apply(newMeasureBuilder().create(Measure.Level.OK))).isFalse();
  }
  @Test
  public void apply_returns_false_if_measure_has_data_for_Boolean_Metric_and_best_value_1() {
    Predicate<Measure> underTest = BestValueOptimization.from(METRIC_BOOLEAN_TRUE, FILE_COMPONENT);

    assertThat(underTest.apply(newMeasureBuilder().create(true, SOME_DATA))).isFalse();
    assertThat(underTest.apply(newMeasureBuilder().create(false, SOME_DATA))).isFalse();
  }
  @Test(enabled = true)
  public void testShellAccess() throws IOException {
    final String nameOfServer = "Server" + String.valueOf(new Date().getTime()).substring(6);
    serversToDeleteAfterTheTests.add(nameOfServer);

    Set<Ip> availableIps = client.getIpServices().getUnassignedIpList();
    Ip availableIp = Iterables.getLast(availableIps);

    Server createdServer =
        client
            .getServerServices()
            .addServer(
                nameOfServer, "GSI-f8979644-e646-4711-ad58-d98a5fa3612c", "1", availableIp.getIp());
    assertNotNull(createdServer);
    assert serverLatestJobCompleted.apply(createdServer);

    // get server by name
    Set<Server> response = client.getServerServices().getServersByName(nameOfServer);
    assert (response.size() == 1);
    createdServer = Iterables.getOnlyElement(response);

    Map<String, Credentials> credsMap = client.getServerServices().getServerCredentialsList();
    LoginCredentials instanceCredentials =
        LoginCredentials.fromCredentials(credsMap.get(createdServer.getName()));
    assertNotNull(instanceCredentials);

    HostAndPort socket = HostAndPort.fromParts(createdServer.getIp().getIp(), 22);

    Predicate<HostAndPort> socketOpen = retry(new InetSocketAddressConnect(), 180, 5, SECONDS);

    socketOpen.apply(socket);

    SshClient sshClient =
        gocontext
            .utils()
            .injector()
            .getInstance(SshClient.Factory.class)
            .create(socket, instanceCredentials);
    sshClient.connect();
    String output = sshClient.exec("df").getOutput();
    assertTrue(
        output.contains("Filesystem"),
        "The output should've contained filesystem information, but it didn't. Output: " + output);
    sshClient.disconnect();

    // check that the get credentials call is the same as this
    assertEquals(
        client.getServerServices().getServerCredentials(createdServer.getId()),
        instanceCredentials);

    try {
      assertEquals(client.getServerServices().getServerCredentials(Long.MAX_VALUE), null);
    } catch (AssertionError e) {
      e.printStackTrace();
    }

    // delete the server
    client.getServerServices().deleteByName(nameOfServer);
  }
  public static DescribeServicesResponseType describeService(final DescribeServicesType request) {
    final DescribeServicesResponseType reply = request.getReply();
    Topology.touch(request);
    if (request.getServices().isEmpty()) {
      final ComponentId compId =
          (request.getByServiceType() != null)
              ? ComponentIds.lookup(request.getByServiceType().toLowerCase())
              : Empyrean.INSTANCE;
      final boolean showEventStacks = Boolean.TRUE.equals(request.getShowEventStacks());
      final boolean showEvents = Boolean.TRUE.equals(request.getShowEvents()) || showEventStacks;

      final Function<ServiceConfiguration, ServiceStatusType> transformToStatus =
          ServiceConfigurations.asServiceStatus(showEvents, showEventStacks);
      final List<Predicate<ServiceConfiguration>> filters =
          new ArrayList<Predicate<ServiceConfiguration>>() {
            {
              if (request.getByPartition() != null) {
                Partitions.exists(request.getByPartition());
                this.add(Filters.partition(request.getByPartition()));
              }
              if (request.getByState() != null) {
                final Component.State stateFilter =
                    Component.State.valueOf(request.getByState().toUpperCase());
                this.add(Filters.state(stateFilter));
              }
              if (!request.getServiceNames().isEmpty()) {
                this.add(Filters.name(request.getServiceNames()));
              }
              this.add(Filters.host(request.getByHost()));
              this.add(
                  Filters.listAllOrInternal(
                      request.getListAll(),
                      request.getListUserServices(),
                      request.getListInternal()));
            }
          };
      final Predicate<Component> componentFilter = Filters.componentType(compId);
      final Predicate<ServiceConfiguration> configPredicate = Predicates.and(filters);

      List<ServiceConfiguration> replyConfigs = Lists.newArrayList();
      for (final Component comp : Components.list()) {
        if (componentFilter.apply(comp)) {
          Collection<ServiceConfiguration> acceptedConfigs =
              Collections2.filter(comp.services(), configPredicate);
          replyConfigs.addAll(acceptedConfigs);
        }
      }
      ImmutableList<ServiceConfiguration> sortedReplyConfigs =
          ServiceOrderings.defaultOrdering().immutableSortedCopy(replyConfigs);
      final Collection<ServiceStatusType> transformedReplyConfigs =
          Collections2.transform(sortedReplyConfigs, transformToStatus);
      reply.getServiceStatuses().addAll(transformedReplyConfigs);
    } else {
      for (ServiceId s : request.getServices()) {
        reply.getServiceStatuses().add(TypeMappers.transform(s, ServiceStatusType.class));
      }
    }
    return reply;
  }
  @Test
  public void apply_returns_false_if_component_is_not_a_FILE_for_Boolean_Metric_and_best_value_1() {
    Predicate<Measure> underTest =
        BestValueOptimization.from(METRIC_BOOLEAN_TRUE, SOME_NON_FILE_COMPONENT);

    assertThat(underTest.apply(newMeasureBuilder().create(true))).isFalse();
    assertThat(underTest.apply(newMeasureBuilder().create(false))).isFalse();
  }
Example #11
0
  @Test
  public void test_filter() {
    Predicate<AstNode> predicate = mock(Predicate.class);
    assertThat((Object) select.filter(predicate)).isSameAs(AstSelectFactory.empty());

    when(predicate.apply(node)).thenReturn(true);
    assertThat((Object) select.filter(predicate)).isSameAs(select);
  }
 protected <STATE, STACKITEM> TraceItem<STATE, STACKITEM> traceToWithPruningStack(
     IPdaAdapter<STATE, STACKITEM> pda,
     Iterable<STATE> starts,
     Iterator<STACKITEM> stack,
     Predicate<STATE> matches,
     Predicate<STATE> canPass) {
   StackItem<STACKITEM> stackItem = createStack(stack);
   List<TraceItem<STATE, STACKITEM>> current = Lists.newArrayList();
   Set<STATE> visited = Sets.newHashSet(starts);
   TraceItem<STATE, STACKITEM> result = null;
   for (STATE start : starts) {
     TraceItem<STATE, STACKITEM> item = new TraceItem<STATE, STACKITEM>(null, start, stackItem);
     //			if (matches.apply(start))
     //				result = item;
     current.add(item);
   }
   int counter = stackItem.size() * -1;
   while (current.size() > 0 && counter < visited.size()) {
     List<TraceItem<STATE, STACKITEM>> newCurrent = Lists.newArrayList();
     for (TraceItem<STATE, STACKITEM> trace : current)
       for (STATE follower : pda.getFollowers(trace.state)) {
         if (matches.apply(follower)) {
           TraceItem<STATE, STACKITEM> found =
               new TraceItem<STATE, STACKITEM>(trace, follower, trace.stackitem);
           if (found.stackitem == null) return found;
           if (result == null || result.stackitem.size() > found.stackitem.size()) {
             result = found;
             counter = result.stackitem.size() * -1;
           } else if (result.stackitem.size() == found.stackitem.size()
               && result.size() > found.size()) {
             result = found;
             counter = result.stackitem.size() * -1;
           }
         }
         if (canPass.apply(follower)) {
           STACKITEM push = pda.getPush(follower);
           visited.add(follower);
           if (push != null) {
             StackItem<STACKITEM> pushed = trace.stackitem.push(push);
             newCurrent.add(new TraceItem<STATE, STACKITEM>(trace, follower, pushed));
           } else {
             STACKITEM pop = pda.getPop(follower);
             if (pop != null) {
               if (trace.stackitem != null && pop == trace.stackitem.peek()) {
                 StackItem<STACKITEM> popped = trace.stackitem.pop();
                 newCurrent.add(new TraceItem<STATE, STACKITEM>(trace, follower, popped));
               }
             } else
               newCurrent.add(new TraceItem<STATE, STACKITEM>(trace, follower, trace.stackitem));
           }
         }
       }
     current = newCurrent;
     counter++;
   }
   return result;
 }
 @Test
 public void testGetSensorPredicateNoWhitelist() {
   Object rootElement = Iterables.getOnlyElement(Yamls.parseAll(PLANS_YAML));
   Predicate<String> predicate =
       BrooklynServiceInstanceBindingService.getSensorWhitelistPredicate(rootElement);
   assertNotNull(predicate);
   assertTrue(predicate.apply("foo.bar"));
   assertTrue(predicate.apply("bar.foo"));
 }
Example #14
0
 @Test
 public void testPredicteStringContains() {
   final Predicate<KomeaEvent> predicate =
       PredicateUtils.fromPredicateDto(
           new PredicateDto(PredicateType.STRING_CONTAINS, "eventString", "zert"));
   assertFalse(predicate.apply(newEvent("project_1", null, new DateTime().toDate(), 10)));
   assertFalse(predicate.apply(newEvent("project_1", "azety", new DateTime().toDate(), 10)));
   assertTrue(predicate.apply(newEvent("project_1", "azerty", new DateTime().toDate(), 10)));
 }
  // Suggest at least 15 minutes for timeout
  public static String waitForPasswordOnAws(
      ComputeService computeService, final NodeMetadata node, long timeout, TimeUnit timeUnit)
      throws TimeoutException {
    ComputeServiceContext computeServiceContext = computeService.getContext();
    AWSEC2Api ec2Client = computeServiceContext.unwrapApi(AWSEC2Api.class);
    final WindowsApi client = ec2Client.getWindowsApi().get();
    final String region = node.getLocation().getParent().getId();

    // The Administrator password will take some time before it is ready - Amazon says sometimes 15
    // minutes.
    // So we create a predicate that tests if the password is ready, and wrap it in a retryable
    // predicate.
    Predicate<String> passwordReady =
        new Predicate<String>() {
          @Override
          public boolean apply(String s) {
            if (Strings.isNullOrEmpty(s)) return false;
            PasswordData data = client.getPasswordDataInRegion(region, s);
            if (data == null) return false;
            return !Strings.isNullOrEmpty(data.getPasswordData());
          }
        };

    LOG.info("Waiting for password, for " + node.getProviderId() + ":" + node.getId());
    Predicate<String> passwordReadyRetryable =
        Predicates2.retry(
            passwordReady, timeUnit.toMillis(timeout), 10 * 1000, TimeUnit.MILLISECONDS);
    boolean ready = passwordReadyRetryable.apply(node.getProviderId());
    if (!ready)
      throw new TimeoutException(
          "Password not available for "
              + node
              + " in region "
              + region
              + " after "
              + timeout
              + " "
              + timeUnit.name());

    // Now pull together Amazon's encrypted password blob, and the private key that jclouds
    // generated
    PasswordDataAndPrivateKey dataAndKey =
        new PasswordDataAndPrivateKey(
            client.getPasswordDataInRegion(region, node.getProviderId()),
            node.getCredentials().getPrivateKey());

    // And apply it to the decryption function
    WindowsLoginCredentialsFromEncryptedData f =
        computeServiceContext
            .utils()
            .injector()
            .getInstance(WindowsLoginCredentialsFromEncryptedData.class);
    LoginCredentials credentials = f.apply(dataAndKey);

    return credentials.getPassword();
  }
 @Test(dependsOnMethods = "testCreateAndStartServer")
 public void testConnectivity() throws Exception {
   HostAndPort vncsocket = HostAndPort.fromParts(server.getVnc().getIp(), 5900);
   Logger.getAnonymousLogger().info("awaiting vnc: " + vncsocket);
   assert socketTester.apply(vncsocket) : server;
   HostAndPort sshsocket = HostAndPort.fromParts(server.getNics().get(0).getDhcp(), 22);
   Logger.getAnonymousLogger().info("awaiting ssh: " + sshsocket);
   assert socketTester.apply(sshsocket) : server;
   doConnectViaSsh(server, getSshCredentials(server));
 }
  @Test
  public void
      apply_returns_false_if_measure_has_anything_else_than_value_for_Boolean_Metric_and_best_value_1() {
    Predicate<Measure> underTest = BestValueOptimization.from(METRIC_BOOLEAN_TRUE, FILE_COMPONENT);

    for (Measure.NewMeasureBuilder builder : builders_of_non_bestValueOptimized_measures()) {
      assertThat(underTest.apply(builder.create(true))).isFalse();
      assertThat(underTest.apply(builder.create(false))).isFalse();
    }
  }
  @Test
  public void verify_value_comparison_for_int_metric() {
    Predicate<Measure> underTest =
        BestValueOptimization.from(createMetric(Metric.MetricType.INT, 10), FILE_COMPONENT);

    assertThat(underTest.apply(newMeasureBuilder().create(10))).isTrue();
    assertThat(underTest.apply(newMeasureBuilder().setVariations(SOME_EMPTY_VARIATIONS).create(10)))
        .isTrue();
    assertThat(underTest.apply(newMeasureBuilder().create(11))).isFalse();
  }
  @Test
  public void apply_returns_true_for_value_false_for_Boolean_Metric_and_best_value_not_1() {
    Predicate<Measure> underTest = BestValueOptimization.from(METRIC_BOOLEAN_FALSE, FILE_COMPONENT);

    assertThat(underTest.apply(newMeasureBuilder().create(true))).isFalse();
    assertThat(underTest.apply(newMeasureBuilder().create(false))).isTrue();
    assertThat(
            underTest.apply(newMeasureBuilder().setVariations(SOME_EMPTY_VARIATIONS).create(false)))
        .isTrue();
  }
  /**
   * 根据条件过滤集合元素
   *
   * @param source
   * @param conditions
   * @param <T>
   * @return 如果全部过滤完则返回null
   */
  public static <T> T filterByOrConditions(Collection<T> source, Predicate<T>... conditions) {

    for (T s : source) {
      for (Predicate<T> condition : conditions) {
        if (condition.apply(s)) return s;
      }
    }

    return null;
  }
Example #21
0
 @Test
 public void testImageDensityFilter() {
   Set<Path> filesToRemove =
       Filters.filterByDensity(candidates, ImmutableSet.of(Density.MDPI), false);
   Predicate<Path> predicate =
       Filters.createImageDensityFilter(candidates, ImmutableSet.of(Density.MDPI), false);
   assertFalse(candidates.isEmpty());
   for (Path candidate : candidates) {
     assertEquals(!filesToRemove.contains(candidate), predicate.apply(candidate));
   }
 }
 @GET
 @Produces(MediaType.APPLICATION_JSON)
 public Response getAllSlots(@Context UriInfo uriInfo) {
   Predicate<RemoteSlot> slotFilter = SlotFilterBuilder.build(uriInfo);
   List<SlotStatusRepresentation> representations = Lists.newArrayList();
   for (RemoteSlot remoteSlot : coordinator.getAllSlots()) {
     if (slotFilter.apply(remoteSlot)) {
       representations.add(SlotStatusRepresentation.from(remoteSlot.status()));
     }
   }
   return Response.ok(representations).build();
 }
 private void verifyPlacementGroup(String region, String groupName) {
   assert availableTester.apply(new PlacementGroup(region, groupName, "cluster", State.PENDING))
       : group;
   Set<PlacementGroup> oneResult =
       client.getPlacementGroupApi().get().describePlacementGroupsInRegion(region, groupName);
   assertNotNull(oneResult);
   assertEquals(oneResult.size(), 1);
   group = oneResult.iterator().next();
   assertEquals(group.getName(), groupName);
   assertEquals(group.getStrategy(), "cluster");
   assert availableTester.apply(group) : group;
 }
  /** Tests server start, reboot and deletion. Also verifies IP services and job services. */
  @Test(enabled = true)
  public void testServerLifecycle() {
    int serverCountBeforeTest = client.getServerServices().getServerList().size();

    final String nameOfServer = "Server" + String.valueOf(new Date().getTime()).substring(6);
    serversToDeleteAfterTheTests.add(nameOfServer);

    Set<Ip> availableIps = client.getIpServices().getUnassignedPublicIpList();
    Ip availableIp = Iterables.getLast(availableIps);

    String ram = Iterables.get(client.getServerServices().getRamSizes(), 0).getName();

    Server createdServer =
        client
            .getServerServices()
            .addServer(
                nameOfServer, "GSI-f8979644-e646-4711-ad58-d98a5fa3612c", ram, availableIp.getIp());
    assertNotNull(createdServer);
    assert serverLatestJobCompleted.apply(createdServer);

    // get server by name
    Set<Server> response = client.getServerServices().getServersByName(nameOfServer);
    assert (response.size() == 1);

    // restart the server
    client.getServerServices().power(nameOfServer, PowerCommand.RESTART);

    Set<Job> jobs = client.getJobServices().getJobsForObjectName(nameOfServer);
    assert ("RestartVirtualServer".equals(Iterables.getLast(jobs).getCommand().getName()));

    assert serverLatestJobCompleted.apply(createdServer);

    int serverCountAfterAddingOneServer = client.getServerServices().getServerList().size();
    assert serverCountAfterAddingOneServer == serverCountBeforeTest + 1
        : "There should be +1 increase in the number of servers since the test started";

    // delete the server
    client.getServerServices().deleteByName(nameOfServer);

    jobs = client.getJobServices().getJobsForObjectName(nameOfServer);
    assert ("DeleteVirtualServer".equals(Iterables.getLast(jobs).getCommand().getName()));

    assert serverLatestJobCompleted.apply(createdServer);

    int serverCountAfterDeletingTheServer = client.getServerServices().getServerList().size();
    assert serverCountAfterDeletingTheServer == serverCountBeforeTest
        : "There should be the same # of servers as since the test started";

    // make sure that IP is put back to "unassigned"
    assert client.getIpServices().getUnassignedIpList().contains(availableIp);
  }
 @Override
 public boolean tree(@Nullable final NodeRef left, @Nullable final NodeRef right) {
   if (!treeNodeFilter.apply(left) || !treeNodeFilter.apply(right)) {
     return false;
   }
   if (left == null) {
     addEnv(right);
     return false;
   } else if (right == null) {
     addEnv(left);
     return false;
   }
   return true;
 }
 private void assertHasEvent(
     Sensor<?> sensor,
     Predicate<Object> componentPredicate,
     Predicate<? super CharSequence> descriptionPredicate) {
   for (SensorEvent<FailureDescriptor> event : events) {
     if (event.getSensor().equals(sensor)
         && (componentPredicate == null
             || componentPredicate.apply(event.getValue().getComponent()))
         && (descriptionPredicate == null
             || descriptionPredicate.apply(event.getValue().getDescription()))) {
       return;
     }
   }
   fail("No matching " + sensor + " event found; events=" + events);
 }
  /**
   * Verify that some non-looping paths from {@code a} to {@code b} pass through at least one node
   * where {@code nodePredicate} is true.
   */
  private boolean checkSomePathsWithoutBackEdges(DiGraphNode<N, E> a, DiGraphNode<N, E> b) {
    if (nodePredicate.apply(a.getValue()) && (inclusive || (a != start && a != end))) {
      return true;
    }
    if (a == b) {
      return false;
    }
    for (DiGraphEdge<N, E> e : a.getOutEdges()) {
      // Once we visited that edge once, we no longer need to
      // re-visit it again.
      if (e.getAnnotation() == VISITED_EDGE) {
        continue;
      }
      e.setAnnotation(VISITED_EDGE);

      if (ignoreEdge(e)) {
        continue;
      }
      if (e.getAnnotation() == BACK_EDGE) {
        continue;
      }

      DiGraphNode<N, E> next = e.getDestination();
      if (checkSomePathsWithoutBackEdges(next, b)) {
        return true;
      }
    }
    return false;
  }
 @Test
 public void testHistoryRunningPredicateFalse() {
   ReportHistory history = createTestHistory();
   // history not running
   sut = new HistoryReadyPredicate(history);
   assertFalse(sut.apply(status));
 }
  /** For each node, update the block stack and reference collection as appropriate. */
  @Override
  public void visit(NodeTraversal t, Node n, Node parent) {
    if (n.isName()
        || n.isRest()
        || (n.isStringKey() && parent.isObjectPattern() && !n.hasChildren())) {
      Var v;
      if (n.getString().equals("arguments")) {
        v = t.getScope().getArgumentsVar();
      } else {
        v = t.getScope().getVar(n.getString());
      }

      if (v != null) {
        if (varFilter.apply(v)) {
          addReference(v, new Reference(n, t, peek(blockStack)));
        }

        if (v.getParentNode() != null
            && NodeUtil.isHoistedFunctionDeclaration(v.getParentNode())
            &&
            // If we're only traversing a narrow scope, do not try to climb outside.
            (narrowScope == null || narrowScope.getDepth() <= v.getScope().getDepth())) {
          outOfBandTraversal(v);
        }
      }
    }

    if (isBlockBoundary(n, parent)) {
      pop(blockStack);
    }
  }
Example #30
0
  private static <T> T lookupMBean(
      final Map<String, String> props,
      final Class<T> type,
      final Predicate<T> tester,
      final long timeout) {
    long until = System.currentTimeMillis() + timeout;
    do
      try {
        final T bean = Mbeans.lookup(jdbcJmxDomain, props, type);
        tester.apply(bean);
        return bean;
      } catch (UndeclaredThrowableException e) {
        if (Exceptions.isCausedBy(e, InstanceNotFoundException.class)) {
          if (System.currentTimeMillis() < until) {
            try {
              TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e1) {
              Thread.interrupted();
              break;
            }
            LOG.debug("Waiting for MBean " + type.getSimpleName() + "/" + props);
            continue;
          }
          throw new NoSuchElementException(type.getSimpleName() + " " + props.toString());
        } else {
          throw Exceptions.toUndeclared(e);
        }
      }
    while (System.currentTimeMillis() < until);

    throw new NoSuchElementException(type.getSimpleName() + " " + props.toString());
  }