コード例 #1
0
  private void manageProfile(TaskContext context) {
    Container current = fabricService.get().getCurrentContainer();
    ProfileData profileData = createProfileData(context);
    String profileId = context.getConfiguration().get(TEMPLATE_PROFILE_PROPERTY_NAME) + "-" + name;
    Version version = current.getVersion();

    try {
      if (lock.acquire(60, TimeUnit.SECONDS)) {
        if (profileData.isEmpty()) {
          if (version.hasProfile(profileId)) {
            // Just delete the profile
            version.getProfile(profileId).delete(true);
          }
          return;
        } else if (!version.hasProfile(profileId)) {
          // Create the profile
          fabricService.get().getDataStore().createProfile(version.getId(), profileId);
        }

        Profile managedProfile = version.getProfile(profileId);
        // managedProfile.setConfigurations(profileData.getConfigs());
        managedProfile.setFileConfigurations(profileData.getFiles());
        current.addProfiles(managedProfile);
      } else {
        throw new TimeoutException("Timed out waiting for lock");
      }
    } catch (Exception e) {
      LOGGER.error("Error managing work items.", e);
    } finally {
      releaseLock();
    }
  }
コード例 #2
0
 @Override
 public void stop(TaskContext context) {
   Container current = fabricService.get().getCurrentContainer();
   Version version = current.getVersion();
   String profileId = context.getConfiguration().get(TEMPLATE_PROFILE_PROPERTY_NAME) + "-" + name;
   if (version.hasProfile(profileId)) {
     // Just delete the profile
     version.getProfile(profileId).delete(true);
   }
 }
コード例 #3
0
  /**
   * Creates a representation of the profile based on the assigned item for the specified
   * {@linkTaskContext}.
   *
   * @param context
   * @return
   */
  private ProfileData createProfileData(TaskContext context) {
    ProfileData profileData = new ProfileData();
    Set<WorkItem> workItems = assignedWorkItems.get(context);
    if (workItems.isEmpty()) {
      return profileData;
    }

    Container current = fabricService.get().getCurrentContainer();
    Version version = current.getVersion();
    String templateProfileName =
        String.valueOf(context.getConfiguration().get(TEMPLATE_PROFILE_PROPERTY_NAME));
    Profile templateProfile = version.getProfile(templateProfileName);
    Set<String> allFiles = templateProfile.getFileConfigurations().keySet();
    Iterable<String> mvelFiles = Iterables.filter(allFiles, MvelPredicate.INSTANCE);
    Iterable<String> plainFiles =
        Iterables.filter(allFiles, Predicates.not(MvelPredicate.INSTANCE));

    for (String mvelFile : mvelFiles) {
      Key key = new Key(templateProfile.getId(), mvelFile);
      synchronized (templates) {
        CompiledTemplate template = templates.get(key);
        if (template == null) {
          template =
              TemplateCompiler.compileTemplate(
                  new String(templateProfile.getFileConfigurations().get(mvelFile)), parserContext);
          templates.put(key, template);
        }
      }
    }

    for (WorkItem workItem : workItems) {
      Map<String, WorkItem> data = new HashMap<String, WorkItem>();
      data.put(WorkItem.ITEM, workItem);

      // Render templates
      for (String fileTemplate : mvelFiles) {
        String file = renderTemplateName(fileTemplate, workItem);
        Key key = new Key(templateProfile.getId(), fileTemplate);
        try {
          String renderedTemplate =
              TemplateRuntime.execute(templates.get(key), parserContext, data).toString();
          updateProfileData(file, renderedTemplate, profileData);
        } catch (Exception ex) {
          LOGGER.warn("Failed to render {}. Ignoring.", fileTemplate);
        }
      }

      // Copy plain files.
      for (String file : plainFiles) {
        String content = new String(templateProfile.getFileConfigurations().get(file));
        updateProfileData(file, content, profileData);
      }
    }
    return profileData;
  }
コード例 #4
0
    protected void recompile() {
        LOG.debug("Looking for XSDs to recompile");

        Set<String> urls = new TreeSet<String>();
        FabricService fabric = getFabricService();
        Container container = fabric.getCurrentContainer();
        String version = container.getVersion().getId();
        List<Profile> profiles = Containers.overlayProfiles(container);
        List<String> profileIds = Profiles.profileIds(profiles);
        Collection<String> names = fabric.getDataStore().listFiles(version, profileIds, schemaPath);
        for (String name : names) {
            if (name.endsWith(".xsd")) {
                String prefix = schemaPath;
                if (Strings.isNotBlank(prefix)) {
                    prefix += "/";
                }
                urls.add("profile:" + prefix + name);
            }
        }

        LOG.info("Recompiling XSDs at URLs: " + urls);
        startedFlag.set(false);

        ClassLoader classLoader = AriesFrameworkUtil.getClassLoader(bundleContext.getBundle());
        if (classLoader == null) {
            classLoader = getClass().getClassLoader();
        }
        DynamicXJC xjc = new DynamicXJC(classLoader);
        xjc.setSchemaUrls(new ArrayList<String>(urls));
        compileResults = xjc.compileSchemas();
        if (handler != null) {
            handler.onCompileResults(compileResults);
        }
        if (introspector != null) {
            introspector.setClassLoaderProvider("dynamic.jaxb", new ClassLoaderProvider() {
                @Override
                public ClassLoader getClassLoader() {
                    return compileResults.getClassLoader();
                }
            });
        }
    }
コード例 #5
0
  @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();
    }
  }