Пример #1
0
  /**
   * Test with a distributed execution with explicit colocation of two functions end up on the same
   * container.
   */
  @Test
  public void testSimpleDistributedColocate() throws Exception {
    assumeTrue(SC_OK);
    assumeTrue(getTesterType() == StreamsContext.Type.DISTRIBUTED_TESTER);

    Topology t = newTopology();

    TStream<String> sa = t.strings("a");
    TStream<String> sb = t.strings("b");

    sa = sa.transform(IsolateTest.getContainerId());
    sb = sb.transform(IsolateTest.getContainerId());

    sa.colocate(sb);

    sa = sa.isolate().filter(new AllowAll<String>());
    sb = sb.isolate().filter(new AllowAll<String>());

    sa = sa.union(sb);

    Condition<List<String>> pes = t.getTester().stringContents(sa, "");

    Condition<Long> tc = t.getTester().tupleCount(sa, 2);

    complete(t.getTester(), tc, 10, TimeUnit.SECONDS);

    Set<String> singlePe = new HashSet<>(pes.getResult());

    assertTrue(pes.getResult().toString(), singlePe.size() == 1);
  }
Пример #2
0
  @Test
  public void testFusing() {
    assumeTrue(isMainRun());
    Topology t = newTopology();
    TStream<String> s1 = t.strings("3");
    TStream<String> s2 = t.strings("3");
    TStream<String> snf = t.strings("3");

    assertTrue(s1.isPlaceable());

    assertSame(s1.colocate(s2), s1);

    String id1 = getFusingId(s1);
    String id2 = getFusingId(s2);

    assertNotNull(id1);
    assertFalse(id1.isEmpty());

    assertEquals(id1, id2);

    TStream<String> s3 = t.strings("3");
    TStream<String> s4 = t.strings("3");
    TSink s5 = s4.print();
    assertTrue(s5.isPlaceable());

    assertSame(s3.colocate(s4, s5), s3);
    assertEquals(getFusingId(s3), getFusingId(s4));
    assertEquals(getFusingId(s3), getColocate(s5.operator()));

    assertFalse(getFusingId(s1).equals(getFusingId(s3)));

    assertNull(getFusingId(snf));

    TStream<String> s6 = StringStreams.toString(s4);
    s1.colocate(s6);
    assertEquals(getFusingId(s1), getFusingId(s6));
  }
Пример #3
0
  @Test
  public void testTags() {
    assumeTrue(isMainRun());
    Topology t = newTopology();
    TStream<String> s1 = t.strings("3");
    TStream<String> s2 = t.strings("3");
    TStream<String> s3 = t.strings("3");

    s1.addResourceTags();
    assertNull(getResourceTags(s1));

    s2.addResourceTags("A", "B");
    Set<String> s2s = getResourceTags(s2);
    assertEquals(2, s2s.size());
    assertTrue(s2s.contains("A"));
    assertTrue(s2s.contains("B"));

    s3.addResourceTags("C", "D", "E");
    Set<String> s3s = getResourceTags(s3);
    assertEquals(3, s3s.size());
    assertTrue(s3s.contains("C"));
    assertTrue(s3s.contains("D"));
    assertTrue(s3s.contains("E"));

    s2s = getResourceTags(s2);
    assertEquals(2, s2s.size());
    assertTrue(s2s.contains("A"));
    assertTrue(s2s.contains("B"));

    s2.addResourceTags("X", "Y");
    s2s = getResourceTags(s2);
    assertEquals(4, s2s.size());
    assertTrue(s2s.contains("A"));
    assertTrue(s2s.contains("B"));
    assertTrue(s2s.contains("X"));
    assertTrue(s2s.contains("Y"));

    // Colocating means the s1 will inherit
    // s3 resource tags
    s1.colocate(s3);
    Set<String> s1s = getResourceTags(s1);
    assertEquals(3, s1s.size());
    assertTrue(s1s.contains("C"));
    assertTrue(s1s.contains("D"));
    assertTrue(s1s.contains("E"));
  }
Пример #4
0
  @SuppressWarnings("unused")
  @Test(expected = IllegalStateException.class)
  public void testColocateLowLatencyRegions() throws Exception {
    assumeTrue(isMainRun());

    // ensure colocating two low latency regions doesn't break lowLatancy
    // and colocating is achieved.

    Topology t = newTopology("testColocateLowLatencyRegions");
    Tester tester = t.getTester();
    // getConfig().put(ContextProperties.KEEP_ARTIFACTS, true);

    TStream<String> s1 =
        t.strings("a").lowLatency().modify(getContainerIdAppend()).modify(getContainerIdAppend());
    s1.endLowLatency();

    TStream<String> s2 =
        t.strings("A").lowLatency().modify(getContainerIdAppend()).modify(getContainerIdAppend());
    s2.endLowLatency();

    s1.colocate(s2); // expect throw ISE: colocate in a low latency region

    // once it's supported... (today it breaks the low latency guarantee)
    // and adjust isMainRun() too
    //        // Given the default fuse-island behavior, expect islands to continue
    //        // to be fused, now both in a single container.
    //
    //        // Today FAILING in an interesting way.
    //        // There are 2 PEs:
    //        // - one has just the single colocated s1 and s2 modify ops
    //        // - the other has everything else
    //
    //        TStream<String> all = s1.union(s2);
    //        all.print();
    //        Condition<Long> nTuples = tester.tupleCount(all.filter(new AllowAll<String>()), 2);
    //        Condition<List<String>> contents = tester.stringContents(
    //                all.filter(new AllowAll<String>()), "");
    //
    //        complete(tester, nTuples, 10, TimeUnit.SECONDS);
    //
    //        Set<String> ids = getContainerIds(contents.getResult());
    //        assertEquals("ids: "+ids, 1, ids.size());
  }