Пример #1
0
  @Test
  public void testIndexTask() throws Exception {
    final Task indexTask =
        new IndexTask(
            null,
            null,
            new IndexTask.IndexIngestionSpec(
                new DataSchema(
                    "foo",
                    null,
                    new AggregatorFactory[] {new DoubleSumAggregatorFactory("met", "met")},
                    new UniformGranularitySpec(
                        Granularity.DAY, null, ImmutableList.of(new Interval("2010-01-01/P2D"))),
                    mapper),
                new IndexTask.IndexIOConfig(new MockFirehoseFactory(false)),
                new IndexTask.IndexTuningConfig(10000, 10, -1, indexSpec)),
            mapper,
            null);

    final Optional<TaskStatus> preRunTaskStatus = tsqa.getStatus(indexTask.getId());
    Assert.assertTrue("pre run task status not present", !preRunTaskStatus.isPresent());

    final TaskStatus mergedStatus = runTask(indexTask);
    final TaskStatus status = ts.getStatus(indexTask.getId()).get();
    final List<DataSegment> publishedSegments = byIntervalOrdering.sortedCopy(mdc.getPublished());
    final List<DataSegment> loggedSegments =
        byIntervalOrdering.sortedCopy(tsqa.getInsertedSegments(indexTask.getId()));

    Assert.assertEquals("statusCode", TaskStatus.Status.SUCCESS, status.getStatusCode());
    Assert.assertEquals(
        "merged statusCode", TaskStatus.Status.SUCCESS, mergedStatus.getStatusCode());
    Assert.assertEquals("segments logged vs published", loggedSegments, publishedSegments);
    Assert.assertEquals("num segments published", 2, mdc.getPublished().size());
    Assert.assertEquals("num segments nuked", 0, mdc.getNuked().size());

    Assert.assertEquals("segment1 datasource", "foo", publishedSegments.get(0).getDataSource());
    Assert.assertEquals(
        "segment1 interval",
        new Interval("2010-01-01/P1D"),
        publishedSegments.get(0).getInterval());
    Assert.assertEquals(
        "segment1 dimensions",
        ImmutableList.of("dim1", "dim2"),
        publishedSegments.get(0).getDimensions());
    Assert.assertEquals(
        "segment1 metrics", ImmutableList.of("met"), publishedSegments.get(0).getMetrics());

    Assert.assertEquals("segment2 datasource", "foo", publishedSegments.get(1).getDataSource());
    Assert.assertEquals(
        "segment2 interval",
        new Interval("2010-01-02/P1D"),
        publishedSegments.get(1).getInterval());
    Assert.assertEquals(
        "segment2 dimensions",
        ImmutableList.of("dim1", "dim2"),
        publishedSegments.get(1).getDimensions());
    Assert.assertEquals(
        "segment2 metrics", ImmutableList.of("met"), publishedSegments.get(1).getMetrics());
  }
Пример #2
0
  @Override
  public List<OProperty> listProperties(
      OClass oClass, String tab, final DisplayMode mode, final Boolean extended) {
    Collection<OProperty> properties = oClass.properties();
    final String safeTab = tab != null ? tab : DEFAULT_TAB;
    final UIComponentsRegistry registry = OrienteerWebApplication.get().getUIComponentsRegistry();
    Collection<OProperty> filteredProperties =
        Collections2.filter(
            properties,
            new Predicate<OProperty>() {

              @Override
              public boolean apply(OProperty input) {
                String propertyTab = CustomAttributes.TAB.getValue(input);
                boolean ret = safeTab.equals(propertyTab != null ? propertyTab : DEFAULT_TAB);
                if (extended == null) return ret;
                else {
                  CustomAttributes attr =
                      DisplayMode.EDIT.equals(mode)
                          ? CustomAttributes.EDIT_COMPONENT
                          : CustomAttributes.VIEW_COMPONENT;
                  String component = attr.getValue(input);
                  if (component == null) return !extended;
                  return registry.getComponentFactory(mode, input.getType(), component).isExtended()
                      == extended;
                }
              }
            });
    if (filteredProperties == null || filteredProperties.isEmpty()) filteredProperties = properties;
    return ORDER_PROPERTIES_BY_ORDER.sortedCopy(filteredProperties);
  }
  @Override
  public Iterator<? extends T> iterator(long first, long count) {
    Collection<T> data = dataModel.getObject();
    if (data == null || data.size() == 0) return Iterators.emptyIterator();
    Iterator<T> it;
    final SortParam<S> sortParam = getSort();
    if (sortParam != null && sortParam.getProperty() != null) {
      Ordering<T> ordering =
          Ordering.natural()
              .nullsFirst()
              .onResultOf(
                  new Function<T, Comparable<?>>() {

                    @Override
                    public Comparable<?> apply(T input) {
                      return comparableValue(input, sortParam.getProperty());
                    }
                  });
      if (!sortParam.isAscending()) ordering = ordering.reverse();
      it = ordering.sortedCopy(data).iterator();
    } else {
      it = data.iterator();
    }
    if (first > 0) Iterators.advance(it, (int) first);
    return count >= 0 ? Iterators.limit(it, (int) count) : it;
  }
Пример #4
0
  public void testSortedCopy() {
    List<Integer> unsortedInts = Collections.unmodifiableList(Arrays.asList(5, 0, 3, null, 0, 9));
    List<Integer> sortedInts = numberOrdering.nullsLast().sortedCopy(unsortedInts);
    assertEquals(Arrays.asList(0, 0, 3, 5, 9, null), sortedInts);

    assertEquals(
        Collections.emptyList(), numberOrdering.sortedCopy(Collections.<Integer>emptyList()));
  }
Пример #5
0
 @Override
 public List<OProperty> getDisplayableProperties(OClass oClass) {
   Collection<OProperty> properties = oClass.properties();
   Collection<OProperty> filteredProperties =
       Collections2.filter(properties, PropertyDisplayablePredicate.INSTANCE);
   if (filteredProperties == null || filteredProperties.isEmpty()) filteredProperties = properties;
   return ORDER_PROPERTIES_BY_ORDER.sortedCopy(filteredProperties);
 }
Пример #6
0
    void testSortedCopy() {
      List<T> shuffledList = Lists.newArrayList(strictlyOrderedList);
      shuffledList = shuffledCopy(shuffledList, new Random(5));

      assertEquals(strictlyOrderedList, ordering.sortedCopy(shuffledList));

      if (!strictlyOrderedList.contains(null)) {
        assertEquals(strictlyOrderedList, ordering.immutableSortedCopy(shuffledList));
      }
    }
    public BrokenDownSummaryConfusionMatrix<SignatureType> build() {
      final ImmutableMap.Builder<SignatureType, SummaryConfusionMatrix> ret =
          ImmutableMap.builder();

      for (final SignatureType key : keyOrdering.sortedCopy(data.keySet())) {
        ret.put(key, data.get(key).build());
      }

      return BrokenDownSummaryConfusionMatrix.fromMap(ret.build());
    }
  /**
   * Get a flat list of validation messages
   *
   * <p>One message has the form:
   *
   * <pre>
   *     #/pointer/here: message here
   * </pre>
   *
   * <p>The list is sorted by pointer.
   *
   * @return the list of messages
   */
  public List<String> getMessages() {
    final Iterable<JsonPointer> paths = Ordering.natural().sortedCopy(msgMap.keySet());

    final ImmutableList.Builder<String> builder = ImmutableList.builder();

    List<Message> messages;

    for (final JsonPointer path : paths) {
      messages = MESSAGE_ORDER.sortedCopy(msgMap.get(path));
      for (final Message msg : messages) builder.add(path + ": " + msg);
    }

    return builder.build();
  }
Пример #9
0
  public void testAllEqual() {
    Ordering<Object> comparator = Ordering.allEqual();
    assertSame(comparator, comparator.reverse());

    assertEquals(comparator.compare(null, null), 0);
    assertEquals(comparator.compare(new Object(), new Object()), 0);
    assertEquals(comparator.compare("apples", "oranges"), 0);
    assertSame(comparator, reserialize(comparator));
    assertEquals("Ordering.allEqual()", comparator.toString());

    List<String> strings = ImmutableList.of("b", "a", "d", "c");
    assertEquals(strings, comparator.sortedCopy(strings));
    assertEquals(strings, comparator.immutableSortedCopy(strings));
  }
  /**
   * Retrieve all messages as a JSON object
   *
   * <p>The retrieved JSON document is an object where:
   *
   * <ul>
   *   <li>keys are string representations of {@link JsonPointer}s,
   *   <li>values are arrays of objects where each individual object is the JSON representation of
   *       one message.
   * </ul>
   *
   * <p>Note: the returned {@link JsonNode} is mutable.
   *
   * @see Message#toJsonNode()
   * @return a JSON object with all validation messages
   */
  public JsonNode asJsonObject() {
    final ObjectNode ret = JsonNodeFactory.instance.objectNode();

    ArrayNode node;
    List<Message> messages;

    for (final JsonPointer ptr : msgMap.keySet()) {
      node = JsonNodeFactory.instance.arrayNode();
      messages = MESSAGE_ORDER.sortedCopy(msgMap.get(ptr));
      for (final Message message : messages) node.add(message.toJsonNode());
      ret.put(ptr.toString(), node);
    }

    return ret;
  }
Пример #11
0
  /**
   * Enumerates all the fields in this state interface.
   *
   * @param clazz a subclass of AccumulatorState
   * @return list of state fields. Ordering is guaranteed to be stable, and have all primitive
   *     fields at the beginning.
   */
  private static List<StateField> enumerateFields(Class<?> clazz) {
    ImmutableList.Builder<StateField> builder = ImmutableList.builder();
    final Set<Class<?>> primitiveClasses =
        ImmutableSet.<Class<?>>of(byte.class, boolean.class, long.class, double.class);
    Set<Class<?>> supportedClasses =
        ImmutableSet.<Class<?>>of(byte.class, boolean.class, long.class, double.class, Slice.class);

    for (Method method : clazz.getMethods()) {
      if (method.getName().equals("getEstimatedSize")) {
        continue;
      }
      if (method.getName().startsWith("get")) {
        Class<?> type = method.getReturnType();
        checkArgument(supportedClasses.contains(type), type.getName() + " is not supported");
        String name = method.getName().substring(3);
        builder.add(new StateField(name, type, getInitialValue(method)));
      }
      if (method.getName().startsWith("is")) {
        Class<?> type = method.getReturnType();
        checkArgument(type == boolean.class, "Only boolean is support for 'is' methods");
        String name = method.getName().substring(2);
        builder.add(new StateField(name, type, getInitialValue(method), method.getName()));
      }
    }

    // We need this ordering because the serializer and deserializer are on different machines, and
    // so the ordering of fields must be stable
    Ordering<StateField> ordering =
        new Ordering<StateField>() {
          @Override
          public int compare(StateField left, StateField right) {
            if (primitiveClasses.contains(left.getType())
                && !primitiveClasses.contains(right.getType())) {
              return -1;
            }
            if (primitiveClasses.contains(right.getType())
                && !primitiveClasses.contains(left.getType())) {
              return 1;
            }
            // If they're the category, just sort by name
            return left.getName().compareTo(right.getName());
          }
        };
    List<StateField> fields = ordering.sortedCopy(builder.build());
    checkInterface(clazz, fields);

    return fields;
  }
Пример #12
0
  private static void runLeastOfComparison(int iterations, int elements, int seeds) {
    Random random = new Random(42);
    Ordering<Integer> ordering = Ordering.natural();

    for (int i = 0; i < iterations; i++) {
      List<Integer> list = Lists.newArrayList();
      for (int j = 0; j < elements; j++) {
        list.add(random.nextInt(10 * i + j + 1));
      }

      for (int seed = 1; seed < seeds; seed++) {
        int k = random.nextInt(10 * seed);
        assertEquals(ordering.sortedCopy(list).subList(0, k), ordering.leastOf(list, k));
      }
    }
  }
Пример #13
0
  private void appendChildComments(
      List<Comment> target, ListMultimap<Long, Comment> byParent, long id, String op) {

    Ordering<Comment> ordering = COMMENT_BY_CONFIDENCE;
    if (op != null && prioritizeOpComments) {
      ordering =
          Ordering.natural()
              .reverse()
              .onResultOf((Comment c) -> op.equalsIgnoreCase(c.getName()))
              .compound(ordering);
    }

    List<Comment> children = ordering.sortedCopy(byParent.get(id));
    for (Comment child : children) {
      target.add(child);
      appendChildComments(target, byParent, (int) child.getId(), op);
    }
  }
  /**
   * Return the list of validation messages as a JSON array
   *
   * <p>This method makes its best to order validation messages correctly.
   *
   * <p>Each message in the resulting array is a JSON object, with the contents of the {@link
   * Message} and with an added member named {@code path}, which contains the path into the instance
   * where the error has occurred (as a {@link JsonPointer}).
   *
   * @see Message#toJsonNode()
   * @return a JSON array with all validation messages
   */
  public JsonNode asJsonArray() {
    final ArrayNode ret = JsonNodeFactory.instance.arrayNode();
    ObjectNode node;

    final Iterable<JsonPointer> paths = Ordering.natural().sortedCopy(msgMap.keySet());

    List<Message> messages;

    for (final JsonPointer ptr : paths) {
      messages = MESSAGE_ORDER.sortedCopy(msgMap.get(ptr));
      for (final Message msg : messages) {
        node = JsonNodeFactory.instance.objectNode().put("path", ptr.toString());
        // I hate to do that...
        node.putAll((ObjectNode) msg.toJsonNode());
        ret.add(node);
      }
    }

    return ret;
  }
    public void renderTo(CharSink sink) throws IOException {
      checkNotNull(corefAnnotation);
      final StringBuilder sb = new StringBuilder();
      sb.append(htmlHeader());
      sb.append(javascript());
      sb.append(bodyHeader());
      sb.append("<h1>");
      sb.append(docID);
      sb.append("</h1>\n");
      for (final String type : Ordering.natural().sortedCopy(typeToResponse.keySet())) {
        final Multimap<TypeRoleFillerRealis, Response> trfrToResponse =
            Multimaps.index(
                typeToResponse.get(type),
                TypeRoleFillerRealis.extractFromSystemResponse(
                    corefAnnotation.laxCASNormalizerFunction()));
        sb.append(href(type));
        sb.append("<h2>");
        sb.append(type);
        sb.append("</h2>\n");
        sb.append(closehref());
        sb.append("<div id=\"");
        sb.append(type);
        sb.append("\" style=\"display:none\">\n");

        sb.append("<ul>\n");
        for (final TypeRoleFillerRealis trfr : trfrOrdering.sortedCopy(trfrToResponse.keySet())) {
          final String trfrID = String.format("%s.%s", type, trfr.role().asString());
          sb.append("<li>\n");
          sb.append(String.format("<div id=\"%s\" style=\"display:inherit\" >", trfrID));
          sb.append("<h3>");
          sb.append(
              String.format(
                  "%s-%s:%s - %s",
                  trfr.type().asString(),
                  trfr.role().asString(),
                  trfr.realis().name(),
                  trfr.argumentCanonicalString().string()));
          sb.append("</h3>\n");

          addSection(
              sb,
              trfrID,
              Iterables.transform(
                  trfrToResponse.get(trfr),
                  new Function<Response, String>() {
                    @Override
                    public String apply(final Response r) {
                      return String.format(
                          "%s: %s", r.realis().name(), r.canonicalArgument().string());
                    }
                  }));
          sb.append("</div>\n");
          sb.append("</li>\n");
        }
        sb.append("</ul>\n");
        sb.append("</div>\n");
        sb.append("</li>\n");
      }
      sb.append(bodyFooter());
      sb.append(htmlFooter());

      sink.write(sb.toString());
    }
Пример #16
0
  private static List<AssociationRule> getRuleValues(
      HasRuleValues hasRuleValues, final OutputField outputField) {
    List<AssociationRule> associationRules =
        hasRuleValues.getRuleValues(outputField.getAlgorithm());

    Comparator<AssociationRule> comparator =
        new Comparator<AssociationRule>() {

          private OutputField.RankBasis rankBasis = outputField.getRankBasis();

          private OutputField.RankOrder rankOrder = outputField.getRankOrder();

          @Override
          public int compare(AssociationRule left, AssociationRule right) {
            int order;

            switch (this.rankBasis) {
              case CONFIDENCE:
                order = (getConfidence(left)).compareTo(getConfidence(right));
                break;
              case SUPPORT:
                order = (getSupport(left)).compareTo(getSupport(right));
                break;
              case LIFT:
                order = (getLift(left)).compareTo(getLift(right));
                break;
              case LEVERAGE:
                order = (getLeverage(left)).compareTo(getLeverage(right));
                break;
              case AFFINITY:
                order = (getAffinity(left)).compareTo(getAffinity(right));
                break;
              default:
                throw new UnsupportedFeatureException(outputField, this.rankBasis);
            } // End switch

            switch (this.rankOrder) {
              case ASCENDING:
                return order;
              case DESCENDING:
                return -order;
              default:
                throw new UnsupportedFeatureException(outputField, this.rankOrder);
            }
          }

          private Double getConfidence(AssociationRule rule) {
            return checkRuleFeature(rule, rule.getConfidence());
          }

          private Double getSupport(AssociationRule rule) {
            return checkRuleFeature(rule, rule.getSupport());
          }

          private Double getLift(AssociationRule rule) {
            return checkRuleFeature(rule, rule.getLift());
          }

          private Double getLeverage(AssociationRule rule) {
            return checkRuleFeature(rule, rule.getLeverage());
          }

          private Double getAffinity(AssociationRule rule) {
            return checkRuleFeature(rule, rule.getAffinity());
          }

          private <V> V checkRuleFeature(AssociationRule rule, V value) {

            if (value == null) {
              throw new InvalidFeatureException(rule);
            }

            return value;
          }
        };

    Ordering<AssociationRule> ordering = Ordering.from(comparator);

    return ordering.sortedCopy(associationRules);
  }
Пример #17
0
 public String printJobQueue(Ordering<R> ordering) {
   return Joiner.on('\n').join(ordering.sortedCopy(requests.values()));
 }
Пример #18
0
  @Test
  public void testResumeTasks() throws Exception {
    final Task indexTask =
        new IndexTask(
            null,
            null,
            new IndexTask.IndexIngestionSpec(
                new DataSchema(
                    "foo",
                    null,
                    new AggregatorFactory[] {new DoubleSumAggregatorFactory("met", "met")},
                    new UniformGranularitySpec(
                        Granularity.DAY, null, ImmutableList.of(new Interval("2010-01-01/P2D"))),
                    mapper),
                new IndexTask.IndexIOConfig(new MockFirehoseFactory(false)),
                new IndexTask.IndexTuningConfig(10000, 10, -1, indexSpec)),
            mapper,
            null);

    final long startTime = System.currentTimeMillis();

    // manually insert the task into TaskStorage, waiting for TaskQueue to sync from storage
    ts.insert(indexTask, TaskStatus.running(indexTask.getId()));

    while (tsqa.getStatus(indexTask.getId()).get().isRunnable()) {
      if (System.currentTimeMillis() > startTime + 10 * 1000) {
        throw new ISE("Where did the task go?!: %s", indexTask.getId());
      }

      Thread.sleep(100);
    }

    final TaskStatus status = ts.getStatus(indexTask.getId()).get();
    final List<DataSegment> publishedSegments = byIntervalOrdering.sortedCopy(mdc.getPublished());
    final List<DataSegment> loggedSegments =
        byIntervalOrdering.sortedCopy(tsqa.getInsertedSegments(indexTask.getId()));

    Assert.assertEquals("statusCode", TaskStatus.Status.SUCCESS, status.getStatusCode());
    Assert.assertEquals("segments logged vs published", loggedSegments, publishedSegments);
    Assert.assertEquals("num segments published", 2, mdc.getPublished().size());
    Assert.assertEquals("num segments nuked", 0, mdc.getNuked().size());

    Assert.assertEquals("segment1 datasource", "foo", publishedSegments.get(0).getDataSource());
    Assert.assertEquals(
        "segment1 interval",
        new Interval("2010-01-01/P1D"),
        publishedSegments.get(0).getInterval());
    Assert.assertEquals(
        "segment1 dimensions",
        ImmutableList.of("dim1", "dim2"),
        publishedSegments.get(0).getDimensions());
    Assert.assertEquals(
        "segment1 metrics", ImmutableList.of("met"), publishedSegments.get(0).getMetrics());

    Assert.assertEquals("segment2 datasource", "foo", publishedSegments.get(1).getDataSource());
    Assert.assertEquals(
        "segment2 interval",
        new Interval("2010-01-02/P1D"),
        publishedSegments.get(1).getInterval());
    Assert.assertEquals(
        "segment2 dimensions",
        ImmutableList.of("dim1", "dim2"),
        publishedSegments.get(1).getDimensions());
    Assert.assertEquals(
        "segment2 metrics", ImmutableList.of("met"), publishedSegments.get(1).getMetrics());
  }
Пример #19
0
  @VisibleForTesting
  LocalDate getOptimizedRawUsageStartDate(
      final LocalDate firstEventStartDate,
      final LocalDate targetDate,
      final Iterable<InvoiceItem> existingUsageItems,
      final Map<String, Usage> knownUsage) {

    if (!existingUsageItems.iterator().hasNext()) {
      return firstEventStartDate;
    }
    // Extract all usage billing period known in that catalog
    final Set<BillingPeriod> knownUsageBillingPeriod =
        ImmutableSet.copyOf(
            Iterables.transform(
                knownUsage.values(),
                new Function<Usage, BillingPeriod>() {
                  @Nullable
                  @Override
                  public BillingPeriod apply(final Usage input) {
                    return input.getBillingPeriod();
                  }
                }));

    // Make sure all usage items are sorted by endDate
    final List<InvoiceItem> sortedUsageItems = USAGE_ITEM_ORDERING.sortedCopy(existingUsageItems);

    // Compute an array with one date per BillingPeriod:
    // If BillingPeriod is never defined in the catalog (no need to look for items), we initialize
    // its value
    // such that it cannot be chosen
    //
    final LocalDate[] perBillingPeriodMostRecentConsumableInArrearItemEndDate =
        new LocalDate[BillingPeriod.values().length - 1]; // Exclude the NO_BILLING_PERIOD
    int idx = 0;
    for (BillingPeriod bp : BillingPeriod.values()) {
      if (bp != BillingPeriod.NO_BILLING_PERIOD) {
        final LocalDate makerDateThanCannotBeChosenAsTheMinOfAllDates =
            targetDate.plusMonths(config.getMaxRawUsagePreviousPeriod() * bp.getNumberOfMonths());
        perBillingPeriodMostRecentConsumableInArrearItemEndDate[idx++] =
            (knownUsageBillingPeriod.contains(bp))
                ? null
                : makerDateThanCannotBeChosenAsTheMinOfAllDates;
      }
    }

    final ListIterator<InvoiceItem> iterator =
        sortedUsageItems.listIterator(sortedUsageItems.size());
    while (iterator.hasPrevious()) {
      final InvoiceItem previous = iterator.previous();
      Preconditions.checkState(previous instanceof UsageInvoiceItem);
      final UsageInvoiceItem item = (UsageInvoiceItem) previous;
      final Usage usage = knownUsage.get(item.getUsageName());

      if (perBillingPeriodMostRecentConsumableInArrearItemEndDate[
              usage.getBillingPeriod().ordinal()]
          == null) {
        perBillingPeriodMostRecentConsumableInArrearItemEndDate[
                usage.getBillingPeriod().ordinal()] =
            item.getEndDate();
        if (!containsNullEntries(perBillingPeriodMostRecentConsumableInArrearItemEndDate)) {
          break;
        }
      }
    }

    // Extract the min from all the dates
    LocalDate targetStartDate = null;
    idx = 0;
    for (BillingPeriod bp : BillingPeriod.values()) {
      if (bp != BillingPeriod.NO_BILLING_PERIOD) {
        final LocalDate tmp = perBillingPeriodMostRecentConsumableInArrearItemEndDate[idx];
        final LocalDate targetBillingPeriodDate =
            tmp != null
                ? tmp.minusMonths(config.getMaxRawUsagePreviousPeriod() * bp.getNumberOfMonths())
                : null;
        if (targetStartDate == null
            || (targetBillingPeriodDate != null
                && targetBillingPeriodDate.compareTo(targetStartDate) < 0)) {
          targetStartDate = targetBillingPeriodDate;
        }
        idx++;
      }
    }

    final LocalDate result =
        targetStartDate.compareTo(firstEventStartDate) > 0 ? targetStartDate : firstEventStartDate;
    return result;
  }