Ejemplo n.º 1
0
  @Test
  public void testLocalFabricCluster() throws Exception {
    fabricService = getFabricService();
    // Test autostartup.
    assertNotNull(fabricService);
    CuratorFramework curator = getCurator();
    curator.getZookeeperClient().blockUntilConnectedOrTimedOut();
    Provision.containerAlive(
        Arrays.<Container>asList(new ContainerImpl(null, "root", fabricService)),
        PROVISION_TIMEOUT);
    Container[] containers = fabricService.getContainers();
    assertNotNull(containers);
    assertEquals("Expected to find 1 container", 1, containers.length);
    assertEquals("Expected to find the root container", "root", containers[0].getId());

    // Test that a generated password exists
    // We don't inject the configuration admin as it causes issues when the tracker gets closed.
    ConfigurationAdmin configurationAdmin = getOsgiService(ConfigurationAdmin.class);
    org.osgi.service.cm.Configuration configuration =
        configurationAdmin.getConfiguration(Constants.ZOOKEEPER_CLIENT_PID);
    Dictionary<String, Object> dictionary = configuration.getProperties();
    assertNotNull("Expected a generated zookeeper password", dictionary.get("zookeeper.password"));
    assertTrue(String.valueOf(dictionary.get("zookeeper.url")).endsWith("2182"));
  }
Ejemplo n.º 2
0
  @Test
  public void testRegistryEntries() throws Exception {
    int startingPort = 9090;
    System.err.println(executeCommand("fabric:create -n root"));
    CuratorFramework curator = getCurator();
    // Wait for zookeeper service to become available.
    System.err.println(
        executeCommand("fabric:profile-create --parents feature-camel fabric-camel"));
    System.err.println(
        executeCommand("fabric:profile-create --parents fabric-camel fabric-camel-server"));
    System.err.println(
        executeCommand("fabric:profile-create --parents fabric-camel fabric-camel-client"));
    System.err.println(
        executeCommand(
            "fabric:profile-edit --repositories mvn:org.fusesource.examples.fabric-camel-cluster/features/"
                + System.getProperty("fabric.version")
                + "/xml/features fabric-camel"));

    System.err.println(
        executeCommand("fabric:profile-edit --features camel-server fabric-camel-server"));
    executeCommand("fabric:profile-edit --features camel-client fabric-camel-client");

    Set<Container> containers =
        ContainerBuilder.create(3)
            .withName("fabric-camel")
            .withProfiles("fabric-camel")
            .assertProvisioningResult()
            .build();

    // We will use the first container as a client and the rest as servers.
    Container camelClientContainer = containers.iterator().next();
    containers.remove(camelClientContainer);
    Set<Container> camelServerContainers = new LinkedHashSet<Container>(containers);

    int index = 1;
    for (Container c : camelServerContainers) {
      setData(curator, ZkPath.CONTAINER_PROVISION_RESULT.getPath(c.getId()), "changing");
      executeCommand(
          "fabric:container-connect -u admin -p admin "
              + camelClientContainer.getId()
              + " log:set DEBUG");
      System.err.println(
          executeCommand(
              "fabric:profile-create --parents fabric-camel-server fabric-camel-server-" + index));
      System.err.println(
          executeCommand(
              "fabric:profile-edit --pid io.fabric8.examples.camel.loadbalancing.server/portNumber="
                  + (startingPort++)
                  + " fabric-camel-server-"
                  + index));
      System.err.println(executeCommand("fabric:profile-display fabric-camel-server-" + index));
      System.err.println(
          executeCommand(
              "fabric:container-change-profile "
                  + c.getId()
                  + " fabric-camel-server-"
                  + (index++)));
    }

    Provision.provisioningSuccess(camelServerContainers, PROVISION_TIMEOUT);
    setData(
        curator,
        ZkPath.CONTAINER_PROVISION_RESULT.getPath(camelClientContainer.getId()),
        "changing");
    System.err.println(
        executeCommand(
            "fabric:container-change-profile "
                + camelClientContainer.getId()
                + " fabric-camel-client"));
    Provision.provisioningSuccess(
        Arrays.asList(new Container[] {camelClientContainer}), PROVISION_TIMEOUT);

    System.err.println(executeCommand("fabric:container-list"));
    System.err.println(executeCommand("fabric:profile-display --overlay fabric-camel-server"));

    // Check that the entries have been properly propagated.
    Assert.assertNotNull(exists(curator, "/fabric/registry/camel/endpoints/"));
    Assert.assertEquals(1, getChildren(curator, "/fabric/registry/camel/endpoints/").size());
    Thread.sleep(5000);
    System.err.println(
        executeCommand(
            "fabric:container-connect -u admin -p admin "
                + camelClientContainer.getId()
                + " camel:route-list"));
    String response =
        new AnsiString(
                executeCommand(
                    "fabric:container-connect -u admin -p admin "
                        + camelClientContainer.getId()
                        + " camel:route-info fabric-client | grep Failed"))
            .getPlain()
            .toString();
    System.err.println(response);
    int failed = Integer.parseInt(response.replaceAll("[^0-9]", ""));
    Assert.assertEquals("Failed exchanges found on client", 0, failed);

    // We want to kill all but one server, so we take out the first and keep it to the end.
    Container lastActiveServerContainer = camelServerContainers.iterator().next();
    camelServerContainers.remove(lastActiveServerContainer);
    for (Container c : camelServerContainers) {
      c.destroy();
      Thread.sleep(25000);
      response =
          new AnsiString(
                  executeCommand(
                      "fabric:container-connect -u admin -p admin "
                          + camelClientContainer.getId()
                          + " camel:route-info fabric-client | grep Failed"))
              .getPlain()
              .toString();
      System.err.println(response);
      failed = Integer.parseInt(response.replaceAll("[^0-9]", ""));
      Assert.assertEquals(
          "Failed exchanges found after container:" + c.getId() + " shut down", 0, failed);
    }
  }
  @Test
  public void testRegistryEntries() throws Exception {
    System.out.println(executeCommand("fabric:create -n root"));
    System.out.println(executeCommand("fabric:profile-list"));

    ServiceProxy<FabricService> fabricProxy =
        ServiceProxy.createServiceProxy(bundleContext, FabricService.class);
    try {
      FabricService fabricService = fabricProxy.getService();
      CuratorFramework curator = fabricService.adapt(CuratorFramework.class);

      Set<ContainerProxy> containers =
          ContainerBuilder.create(fabricProxy, 3)
              .withName("fabric-camel")
              .withProfiles("feature-camel")
              .assertProvisioningResult()
              .build();
      try {
        // We will use the first container as a client and the rest as servers.
        LinkedList<Container> containerList = new LinkedList<Container>(containers);
        Container client = containerList.removeLast();

        LinkedList<Container> servers = new LinkedList<Container>(containerList);

        for (Container c : servers) {
          Profile p = c.getVersion().getProfile("example-camel-cluster.server");
          c.setProfiles(new Profile[] {p});
        }

        Provision.provisioningSuccess(servers, PROVISION_TIMEOUT);

        Profile p = client.getVersion().getProfile("example-camel-cluster.client");
        client.setProfiles(new Profile[] {p});

        Provision.provisioningSuccess(Arrays.asList(new Container[] {client}), PROVISION_TIMEOUT);

        System.out.println(executeCommand("fabric:container-list"));
        System.out.println(executeCommand("fabric:profile-display --overlay fabric-camel-server"));

        // Check that the entries have been properly propagated.
        Assert.assertNotNull(exists(curator, "/fabric/registry/camel/endpoints"));
        Assert.assertEquals(1, getChildren(curator, "/fabric/registry/camel/endpoints").size());

        Assert.assertTrue(
            Provision.waitForCondition(
                Arrays.asList(client),
                new ContainerCondition() {
                  @Override
                  public Boolean checkConditionOnContainer(final Container c) {
                    return getCompletedExchangesCount(c) > 0;
                  }
                },
                60000L));

        // We want to kill all but one server, so we take out the first and keep it to the end.
        Container lastActiveServerContainer = servers.removeLast();

        for (Container c : servers) {
          try {
            c.destroy(true);
          } catch (Exception ex) {
            // ignore.
          }
          // Get the number of exchanges completed before we kill the server.
          final int completed = getCompletedExchangesCount(client);

          // Ensure that we still have messages flowing
          Assert.assertTrue(
              Provision.waitForCondition(
                  Arrays.asList(client),
                  new ContainerCondition() {
                    @Override
                    public Boolean checkConditionOnContainer(final Container c) {
                      return getCompletedExchangesCount(c) > completed + 3;
                    }
                  },
                  60000L));
        }
        System.out.println(
            new AnsiString(
                    executeCommand(
                        "fabric:container-connect -u admin -p admin "
                            + client.getId()
                            + " camel:route-info fabric-client"))
                .getPlain()
                .toString());
      } finally {
        ContainerBuilder.destroy(containers);
      }
    } finally {
      fabricProxy.close();
    }
  }