public static void main(String[] args) throws Exception {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("integration.xml");

    CamelContext context = (CamelContext) ctx.getBean("camelContext");

    ConnectionFactory cf = new ActiveMQConnectionFactory("tcp://localhost:61616");
    context.addComponent("jms", JmsComponent.jmsComponentAutoAcknowledge(cf));
    context.addRoutes(
        new RouteBuilder() {

          public void configure() {
            from("jms:queue:spring-tweets")
                .process(
                    new Processor() {
                      public void process(Exchange e) {
                        System.out.println("Message: " + e.getIn().getBody());

                        Tweet tweet = (Tweet) e.getIn().getBody();
                        System.out.println("Sender: " + tweet.getFromUser());
                        System.out.println("Text: " + tweet.getText());
                      }
                    });
          }
        });
    context.start();

    while (true) {}
  }
  /**
   * @param args
   * @throws Exception
   */
  public static void main(String[] args) throws Exception {
    CamelContext context = new DefaultCamelContext();

    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("vm:/localhost");
    context.addComponent("jms", JmsComponent.jmsComponentAutoAcknowledge(connectionFactory));

    context.addRoutes(
        new RouteBuilder() {
          public void configure() {
            from("ftp://127.0.0.1/orders?username=johnny&password=quest")
                .process(
                    new Processor() {
                      public void process(Exchange exchange) throws Exception {
                        System.out.println(
                            "\nWe just downloaded: " + exchange.getIn().getHeader("CamelFileName"));
                        System.out.println("Body:");
                        System.out.println(exchange.getIn().getBody());
                        System.out.println("\n==================\n");
                      }
                    })
                .to("jms:incomingOrders");
          }
        });

    context.start();
    Thread.sleep(60000);
    context.stop();
  }
  private void addDTSIncomingFileRouter(final CamelContext context) throws Exception {
    final CIAOConfig config = CamelApplication.getConfig(context);
    final DTSIncomingFileRouterRoute route = new DTSIncomingFileRouterRoute();

    // IN folder properties
    route.setDTSInUri(context.resolvePropertyPlaceholders("file://{{dts.rootFolder}}/IN"));
    route.setDTSMessageReceiverUri("direct:dtsMessageReceiver");
    route.setInIdempotentRepositoryId("dtsReceiverIdempotentRepository");
    route.setInInProgressRepositoryId("dtsReceiverInProgressRepository");

    // SEND folder properties
    route.setDTSSentUri(context.resolvePropertyPlaceholders("file://{{dts.rootFolder}}/SENT"));
    route.setDTSMessageSendNotificationReceiverUri("direct:dtsMessageSendNotificationReceiver");
    route.setSentIdempotentRepositoryId("dtsSentIdempotentRepository");
    route.setSentInProgressRepositoryId("dtsSentInProgressRepository");
    route.setDTSFilePrefix(Strings.nullToEmpty(config.getConfigValue("dts.filePrefix")));

    // common properties
    route.setMailboxes(Arrays.asList(config.getConfigValue("dts.senderMailbox")));

    final Set<String> workflowIds = Sets.newHashSet(config.getConfigValue("dts.workflowId"));
    for (final String workflowId : config.getConfigValue("dts.receiverWorkflowIds").split(",")) {
      if (!workflowId.trim().isEmpty()) {
        workflowIds.add(workflowId);
      }
    }
    route.setWorkflowIds(workflowIds);

    context.addRoutes(route);
  }
  @Test
  public void testUnmarshalJackson() throws Exception {

    CamelContext camelctx = new DefaultCamelContext();
    camelctx.addRoutes(
        new RouteBuilder() {
          @Override
          public void configure() throws Exception {
            from("direct:start").unmarshal().json(JsonLibrary.Jackson, Customer.class);
          }
        });

    String input = "{'firstName':'John','lastName':'Doe'}";

    camelctx.start();
    try {
      ProducerTemplate producer = camelctx.createProducerTemplate();
      Customer customer =
          producer.requestBody("direct:start", input.replace('\'', '"'), Customer.class);
      Assert.assertEquals("John", customer.getFirstName());
      Assert.assertEquals("Doe", customer.getLastName());
    } finally {
      camelctx.stop();
    }
  }
 @Override
 protected CamelContext createCamelContext() throws Exception {
   CamelContext context = super.createCamelContext();
   // simulate JMS with the SEDA component
   context.addComponent("jms", context.getComponent("seda"));
   return context;
 }
  @Test
  public void testSQLEndpoint() throws Exception {
    Assert.assertNotNull("DataSource not null", dataSource);

    CamelContext camelctx = new DefaultCamelContext();
    camelctx.addRoutes(
        new RouteBuilder() {
          @Override
          public void configure() throws Exception {
            from("sql:select name from information_schema.users?dataSource=java:jboss/datasources/ExampleDS")
                .to("direct:end");
          }
        });

    camelctx.start();
    try {
      PollingConsumer pollingConsumer = camelctx.getEndpoint("direct:end").createPollingConsumer();
      pollingConsumer.start();

      String result = (String) pollingConsumer.receive().getIn().getBody(Map.class).get("NAME");
      Assert.assertEquals("SA", result);
    } finally {
      camelctx.stop();
    }
  }
  @Test
  public void writesResultToSender_ConfiguredViaXML() throws Exception {
    String receiver = "*****@*****.**";
    createMailUser(receiver, "loginIdReceiver", "secretOfReceiver");

    String validSender = "*****@*****.**";
    createMailUser(validSender, "loginIdSender", "secretOfSender");
    String commandName = "nameMe";
    sendMailTo(receiver).from(validSender).withSubject(anySubject()).andText(commandName);

    InputStream is = getClass().getResourceAsStream("/ardulinkmail.xml");
    try {
      CamelContext context = new DefaultCamelContext();
      loadRoutesDefinition(is, context, commandName);
      context.start();

      try {
        assertThat(
            ((String) fetchMail("loginIdSender", "secretOfSender").getContent()),
            is(
                "SwitchDigitalPinCommand [pin=1, value=true]=OK\r\n"
                    + "SwitchAnalogPinCommand [pin=2, value=123]=OK"));
      } finally {
        context.stop();
      }
    } finally {
      is.close();
    }
  }
  @Override
  protected Object doExecute() throws Exception {
    CamelContext camel = camelController.getCamelContext(context);
    if (camel == null) {
      System.err.println("CamelContext " + context + " not found.");
      return null;
    }

    BacklogTracer backlogTracer = BacklogTracer.getBacklogTracer(camel);
    if (backlogTracer == null) {
      backlogTracer = (BacklogTracer) camel.getDefaultBacklogTracer();
    }

    backlogTracer.setEnabled(true);
    if (backlogSize != null) {
      backlogTracer.setBacklogSize(backlogSize);
    }
    if (removeOnDump != null) {
      backlogTracer.setRemoveOnDump(removeOnDump);
    }
    backlogTracer.setTracePattern(pattern);
    backlogTracer.setTraceFilter(filter);

    System.out.println(
        "BacklogTracer started on "
            + camel.getName()
            + " with size: "
            + backlogTracer.getBacklogSize());
    return null;
  }
  @Override
  protected void doStart() throws Exception {
    ServiceHelper.startServices(output, outputAsync, deadLetter);
    // use a shared scheduler
    if (executorService == null || executorService.isShutdown()) {
      // camel context will shutdown the executor when it shutdown so no need to shut it down when
      // stopping
      if (executorServiceRef != null) {
        executorService =
            camelContext
                .getExecutorServiceStrategy()
                .lookupScheduled(this, "ErrorHandlerRedeliveryTask", executorServiceRef);
        if (executorService == null) {
          throw new IllegalArgumentException(
              "ExecutorServiceRef " + executorServiceRef + " not found in registry.");
        }
      } else {
        executorService =
            camelContext
                .getExecutorServiceStrategy()
                .newScheduledThreadPool(this, "ErrorHandlerRedeliveryTask");
      }
    }

    // determine if redeliver is enabled or not
    redeliveryEnabled = determineIfRedeliveryIsEnabled();
    if (log.isDebugEnabled()) {
      log.debug("Redelivery enabled: {} on error handler: {}", redeliveryEnabled, this);
    }
  }
  @Test
  public void testOgnlExpressionFromFile() throws Exception {

    CamelContext camelctx = new DefaultCamelContext();
    camelctx.addRoutes(
        new RouteBuilder() {
          @Override
          public void configure() throws Exception {
            from("direct:start")
                .choice()
                .when()
                .ognl("resource:classpath:test-ognl-expression.txt")
                .transform(simple("Hello ${body.name}"))
                .otherwise()
                .to("mock:dlq");
          }
        });

    Person person = new Person();
    person.setName("Kermit");

    camelctx.start();
    try {
      ProducerTemplate producer = camelctx.createProducerTemplate();
      String result = producer.requestBody("direct:start", person, String.class);
      Assert.assertEquals("Hello Kermit", result);
    } finally {
      camelctx.stop();
    }
  }
  @Override
  public Transformer put(TransformerKey key, Transformer transformer) {
    // at first we must see if the key already exists and then replace it back, so it stays the same
    // spot
    Transformer answer = staticMap.remove(key);
    if (answer != null) {
      // replace existing
      staticMap.put(key, transformer);
      return answer;
    }

    answer = super.remove(key);
    if (answer != null) {
      // replace existing
      super.put(key, transformer);
      return answer;
    }

    // we want endpoints to be static if they are part of setting up or starting routes
    if (context.isSetupRoutes() || context.isStartingRoutes()) {
      answer = staticMap.put(key, transformer);
    } else {
      answer = super.put(key, transformer);
    }

    return answer;
  }
  @Test
  public void testBlueprintProperties() throws Exception {
    // start bundle
    getInstalledBundle(name).start();

    // must use the camel context from osgi
    CamelContext ctx =
        getOsgiService(CamelContext.class, "(camel.context.symbolicname=" + name + ")", 10000);

    ProducerTemplate myTemplate = ctx.createProducerTemplate();
    myTemplate.start();

    // do our testing
    MockEndpoint foo = ctx.getEndpoint("mock:foo", MockEndpoint.class);
    foo.expectedMessageCount(1);
    MockEndpoint result = ctx.getEndpoint("mock:result", MockEndpoint.class);
    result.expectedMessageCount(1);

    myTemplate.sendBody("direct:start", "Hello World");

    foo.assertIsSatisfied();
    result.assertIsSatisfied();

    myTemplate.stop();
  }
  protected CamelContext createPropertiesPlaceholderAwareContext(Properties supplementalProperties)
      throws IOException {
    Properties properties = new Properties(supplementalProperties);
    properties.load(AbstractJsseParametersTest.class.getResourceAsStream("test.properties"));

    if (supplementalProperties != null) {
      Properties mergedProps = new Properties();

      Set<String> keys = new HashSet<String>();
      keys.addAll(properties.stringPropertyNames());
      keys.addAll(supplementalProperties.stringPropertyNames());

      for (String key : keys) {
        mergedProps.setProperty(key, properties.getProperty(key));
      }

      properties = mergedProps;
    }

    properties.store(
        new FileOutputStream("./target/jsse-test.properties"),
        "Generated by " + AbstractJsseParametersTest.class.getName());

    PropertiesComponent pc = new PropertiesComponent();
    pc.setLocation("file:./target/jsse-test.properties");

    CamelContext context = new DefaultCamelContext();
    context.addComponent("properties", pc);

    return context;
  }
  public void testTwoManagedCamelContextClash() throws Exception {
    // JMX tests dont work well on AIX CI servers (hangs them)
    if (isPlatform("aix")) {
      return;
    }

    camel1 = createCamelContext("foo", "myFoo");
    camel2 = createCamelContext("foo", "myFoo");

    camel1.start();
    assertTrue("Should be started", camel1.getStatus().isStarted());

    MBeanServer mbeanServer = camel1.getManagementStrategy().getManagementAgent().getMBeanServer();
    ObjectName on =
        ObjectName.getInstance(
            "org.apache.camel:context="
                + camel1.getManagementName()
                + ",type=context,name=\"foo\"");
    assertTrue("Should be registered", mbeanServer.isRegistered(on));

    // we use fixed names, so we will get a clash
    try {
      camel2.start();
      fail("Should have thrown an exception");
    } catch (VetoCamelContextStartException e) {
      assertTrue(e.getMessage().contains("is already registered"));
    }
  }
  @Test
  public void testInvalidCredentials() throws Exception {
    CamelContext camelctx = new DefaultCamelContext();
    camelctx.addRoutes(
        new RouteBuilder() {
          @Override
          public void configure() throws Exception {
            from("direct:start")
                .policy(new DomainAuthorizationPolicy())
                .transform(body().prepend("Hello "));
          }
        });

    camelctx.start();
    try {
      ProducerTemplate producer = camelctx.createProducerTemplate();
      try {
        Subject subject = getAuthenticationToken("user-domain", AnnotatedSLSB.USERNAME, "bogus");
        producer.requestBodyAndHeader(
            "direct:start", "Kermit", Exchange.AUTHENTICATION, subject, String.class);
        Assert.fail("CamelExecutionException expected");
      } catch (CamelExecutionException e) {
        // expected
      }
    } finally {
      camelctx.stop();
    }
  }
Example #16
0
  @Override
  public Object execute(CamelController camelController, PrintStream out, PrintStream err)
      throws Exception {
    final List<CamelContext> camelContexts = camelController.getCamelContexts();

    final Map<String, Integer> columnWidths = computeColumnWidths(camelContexts);
    final String headerFormat = buildFormatString(columnWidths, true);
    final String rowFormat = buildFormatString(columnWidths, false);

    if (camelContexts.size() > 0) {
      out.println(
          String.format(
              headerFormat, CONTEXT_COLUMN_LABEL, STATUS_COLUMN_LABEL, UPTIME_COLUMN_LABEL));
      out.println(String.format(headerFormat, "-------", "------", "------"));
      for (final CamelContext camelContext : camelContexts) {
        out.println(
            String.format(
                rowFormat,
                camelContext.getName(),
                camelContext.getStatus(),
                camelContext.getUptime()));
      }
    }

    return null;
  }
  @Test
  public void testEndpointClass() throws Exception {

    final CountDownLatch latch = new CountDownLatch(3);

    CamelContext camelctx = new DefaultCamelContext();
    camelctx.addRoutes(
        new RouteBuilder() {
          @Override
          public void configure() throws Exception {
            from("quartz2://mytimer?trigger.repeatCount=3&trigger.repeatInterval=100")
                .process(
                    new Processor() {
                      @Override
                      public void process(Exchange exchange) throws Exception {
                        latch.countDown();
                      }
                    })
                .to("mock:result");
          }
        });

    camelctx.start();
    try {
      Assert.assertTrue("Countdown reached zero", latch.await(500, TimeUnit.MILLISECONDS));
    } finally {
      camelctx.stop();
    }
  }
  /**
   * Generate a "help" message.
   *
   * @param exchange the incoming message
   */
  public void process(final Exchange exchange) throws IOException {

    final Message in = exchange.getIn();
    final CamelContext context = exchange.getContext();

    final String fedora;
    final String endpoint;

    try {
      fedora = context.resolvePropertyPlaceholders("{{fcrepo.baseUrl}}");
      endpoint =
          InetAddress.getLocalHost().getHostName()
              + ":"
              + context.resolvePropertyPlaceholders("{{rest.port}}")
              + context.resolvePropertyPlaceholders("{{rest.prefix}}");
    } catch (final Exception ex) {
      throw new RuntimeCamelException("Could not resolve property placeholders", ex);
    }

    final StringBuilder sb = new StringBuilder();
    sb.append("Geneva Synchronization Service\n\n");
    sb.append("\tConfigured Fedora Location: " + fedora + "\n");
    sb.append("\tConfigured REST Endpoint: " + endpoint + "\n\n");
    sb.append("You can POST to defined endpoint, and it will begin\n");
    sb.append("a re-synchronization task with the configured datastore.\n\n");
    sb.append("For example:\n\n");
    sb.append("\tcurl -XPOST " + endpoint + "\n\n");

    in.setBody(sb.toString());
  }
Example #19
0
 /**
  * Resolves the XStream instance to be used by this data format. If XStream is not explicitly set,
  * new instance will be created and cached.
  *
  * @param context to be used during a configuration of the XStream instance
  * @return XStream instance used by this data format.
  */
 public XStream getXStream(CamelContext context) {
   if (xstream == null) {
     xstream =
         createXStream(context.getClassResolver(), context.getApplicationContextClassLoader());
   }
   return xstream;
 }
  @Override
  protected CamelContext createCamelContext() throws Exception {
    // Since the Camel BlueprintComponentResolver does not execute outside
    // of an OSGi container, we cannot
    // rely on the CatalogComponentResolver to be used for resolving the
    // CatalogComponent when Camel loads the route.
    // Therefore, we Mock what the CatalogComponent's blueprint.xml file
    // would have done by creating a
    // CatalogComponent explicitly and adding it to the CamelContext used
    // for this unit test.

    // Configure PojoSR to be our mock OSGi Registry
    final PojoServiceRegistry reg =
        new PojoServiceRegistryFactoryImpl().newPojoServiceRegistry(new HashMap());
    final BundleContext bundleContext = reg.getBundleContext();

    final CamelContext camelContext = super.createCamelContext();
    final CatalogComponent catalogComponent = new CatalogComponent();
    catalogComponent.setBundleContext(bundleContext);
    catalogFramework = mock(CatalogFramework.class);
    catalogComponent.setCatalogFramework(catalogFramework);
    camelContext.addComponent(CatalogComponent.NAME, catalogComponent);

    return camelContext;
  }
Example #21
0
  private static Map<String, Integer> computeColumnWidths(
      final Iterable<CamelContext> camelContexts) throws Exception {
    if (camelContexts == null) {
      throw new IllegalArgumentException(
          "Unable to determine column widths from null Iterable<CamelContext>");
    } else {
      int maxNameLen = 0;
      int maxStatusLen = 0;
      int maxUptimeLen = 0;

      for (final CamelContext camelContext : camelContexts) {
        final String name = camelContext.getName();
        maxNameLen = java.lang.Math.max(maxNameLen, name == null ? 0 : name.length());

        final String status = camelContext.getStatus().toString();
        maxStatusLen = java.lang.Math.max(maxStatusLen, status == null ? 0 : status.length());

        final String uptime = camelContext.getUptime();
        maxUptimeLen = java.lang.Math.max(maxUptimeLen, uptime == null ? 0 : uptime.length());
      }

      final Map<String, Integer> retval = new Hashtable<String, Integer>(3);
      retval.put(NAME_COLUMN_LABEL, maxNameLen);
      retval.put(STATUS_COLUMN_LABEL, maxStatusLen);
      retval.put(UPTIME_COLUMN_LABEL, maxUptimeLen);

      return retval;
    }
  }
  protected CamelContext createCamelContext() throws Exception {
    CamelContext camelContext = super.createCamelContext();

    ConnectionFactory connectionFactory = CamelJmsTestHelper.createConnectionFactory();
    camelContext.addComponent("jms", JmsComponent.jmsComponentAutoAcknowledge(connectionFactory));
    return camelContext;
  }
Example #23
0
 private boolean addRouteToContext(
     Bean<?> routeBean, Bean<?> contextBean, BeanManager manager, AfterDeploymentValidation adv) {
   try {
     CamelContext context = getReference(manager, CamelContext.class, contextBean);
     try {
       Object route = getReference(manager, Object.class, routeBean);
       if (route instanceof RoutesBuilder) {
         context.addRoutes((RoutesBuilder) route);
       } else if (route instanceof RouteContainer) {
         context.addRouteDefinitions(((RouteContainer) route).getRoutes());
       } else {
         throw new IllegalArgumentException(
             "Invalid routes type ["
                 + routeBean.getBeanClass().getName()
                 + "], "
                 + "must be either of type RoutesBuilder or RouteContainer!");
       }
       return true;
     } catch (Exception cause) {
       adv.addDeploymentProblem(
           new InjectionException(
               "Error adding routes of type ["
                   + routeBean.getBeanClass().getName()
                   + "] "
                   + "to Camel context ["
                   + context.getName()
                   + "]",
               cause));
     }
   } catch (Exception exception) {
     adv.addDeploymentProblem(exception);
   }
   return false;
 }
  @Override
  protected CamelContext createCamelContext() throws Exception {

    final CamelContext context = super.createCamelContext();

    // read Olingo component configuration from TEST_OPTIONS_PROPERTIES
    final Properties properties = new Properties();
    try {
      properties.load(getClass().getResourceAsStream(TEST_OPTIONS_PROPERTIES));
    } catch (Exception e) {
      throw new IOException(
          String.format("%s could not be loaded: %s", TEST_OPTIONS_PROPERTIES, e.getMessage()), e);
    }

    Map<String, Object> options = new HashMap<String, Object>();
    for (Map.Entry<Object, Object> entry : properties.entrySet()) {
      options.put(entry.getKey().toString(), entry.getValue());
    }

    final Olingo2Configuration configuration = new Olingo2Configuration();
    IntrospectionSupport.setProperties(configuration, options);

    // add OlingoComponent to Camel context
    final Olingo2Component component = new Olingo2Component(context);
    component.setConfiguration(configuration);
    context.addComponent("olingo2", component);

    return context;
  }
 @Lazy
 @Bean(name = "sql-stored-component")
 @ConditionalOnClass(CamelContext.class)
 @ConditionalOnMissingBean(SqlStoredComponent.class)
 public SqlStoredComponent configureSqlStoredComponent(
     CamelContext camelContext, SqlStoredComponentConfiguration configuration) throws Exception {
   SqlStoredComponent component = new SqlStoredComponent();
   component.setCamelContext(camelContext);
   Map<String, Object> parameters = new HashMap<>();
   IntrospectionSupport.getProperties(configuration, parameters, null, false);
   for (Map.Entry<String, Object> entry : parameters.entrySet()) {
     Object value = entry.getValue();
     Class<?> paramClass = value.getClass();
     if (paramClass.getName().endsWith("NestedConfiguration")) {
       Class nestedClass = null;
       try {
         nestedClass = (Class) paramClass.getDeclaredField("CAMEL_NESTED_CLASS").get(null);
         HashMap<String, Object> nestedParameters = new HashMap<>();
         IntrospectionSupport.getProperties(value, nestedParameters, null, false);
         Object nestedProperty = nestedClass.newInstance();
         IntrospectionSupport.setProperties(
             camelContext, camelContext.getTypeConverter(), nestedProperty, nestedParameters);
         entry.setValue(nestedProperty);
       } catch (NoSuchFieldException e) {
       }
     }
   }
   IntrospectionSupport.setProperties(
       camelContext, camelContext.getTypeConverter(), component, parameters);
   return component;
 }
  @Test
  public void testRoleBasedAccess() throws Exception {
    CamelContext camelctx = new DefaultCamelContext();
    camelctx.addRoutes(
        new RouteBuilder() {
          @Override
          public void configure() throws Exception {
            from("direct:start")
                .policy(new DomainAuthorizationPolicy().roles("Role2"))
                .transform(body().prepend("Hello "));
          }
        });

    camelctx.start();
    try {
      ProducerTemplate producer = camelctx.createProducerTemplate();
      Subject subject =
          getAuthenticationToken("user-domain", AnnotatedSLSB.USERNAME, AnnotatedSLSB.PASSWORD);
      String result =
          producer.requestBodyAndHeader(
              "direct:start", "Kermit", Exchange.AUTHENTICATION, subject, String.class);
      Assert.assertEquals("Hello Kermit", result);
    } finally {
      camelctx.stop();
    }
  }
  @Override
  protected DistributionEnvelopeSenderRoute createDistributionEnvelopeSenderRoute(
      final CamelContext context, final CIAOConfig config) throws Exception {
    final DTSDistributionEnvelopeSenderRoute route = new DTSDistributionEnvelopeSenderRoute();

    route.setDTSMessageSenderUri(
        context.resolvePropertyPlaceholders("file://{{dts.rootFolder}}/OUT"));
    route.setDTSMessageSendNotificationReceiverUri("direct:dtsMessageSendNotificationReceiver");
    route.setDTSTemporaryFolder(context.resolvePropertyPlaceholders("{{dts.temporaryFolder}}"));
    route.setDTSFilePrefix(Strings.nullToEmpty(config.getConfigValue("dts.filePrefix")));
    route.setIdGenerator(get(context, IdGenerator.class, "dtsIdGenerator"));

    // File housekeeping
    final DTSFileHousekeeper fileHousekeeper = new DTSFileHousekeeper();
    fileHousekeeper.setDestinationFolder(
        context.resolvePropertyPlaceholders("{{dts.completedFolder}}"));
    route.setFileHousekeeper(fileHousekeeper);

    final DTSFileHousekeeper errorFileHousekeeper = new DTSFileHousekeeper();
    errorFileHousekeeper.setDestinationFolder(
        context.resolvePropertyPlaceholders("{{dts.errorFolder}}"));
    route.setErrorFileHousekeeper(errorFileHousekeeper);

    final ControlFile prototype = new ControlFile();
    prototype.setWorkflowId(config.getConfigValue("dts.workflowId"));
    prototype.setFromDTS(config.getConfigValue("dts.senderMailbox"));
    route.setPrototypeControlFile(prototype);

    return route;
  }
  @Test
  public void testNoAuthenticationHeader() throws Exception {
    CamelContext camelctx = new DefaultCamelContext();
    camelctx.addRoutes(
        new RouteBuilder() {
          @Override
          public void configure() throws Exception {
            from("direct:start")
                .policy(new DomainAuthorizationPolicy())
                .transform(body().prepend("Hello "));
          }
        });

    camelctx.start();
    try {
      ProducerTemplate producer = camelctx.createProducerTemplate();
      try {
        producer.requestBody("direct:start", "Kermit", String.class);
        Assert.fail("CamelExecutionException expected");
      } catch (CamelExecutionException e) {
        // expected
      }
    } finally {
      camelctx.stop();
    }
  }
  @Test
  public void testHandleException() throws Exception {
    for (int i = 0; i < DELIVERY_COUNT; i++) {
      MockEndpoint finish = consumerContext.getEndpoint("mock:finish" + i, MockEndpoint.class);
      finish.whenAnyExchangeReceived(
          new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
              throw new RuntimeException("TestException!!!");
            }
          });
      finish.expectedBodiesReceived("1234567890");
    }
    MockEndpoint finish4 = consumerContext.getEndpoint("mock:finish4", MockEndpoint.class);
    finish4.expectedBodiesReceived("1234567890-1");

    MockEndpoint exception = producerContext.getEndpoint("mock:exception", MockEndpoint.class);
    exception.expectedBodiesReceived("1234567890");

    ProducerTemplate producerTemplate = producerContext.createProducerTemplate();
    try {
      producerTemplate.sendBody("direct:start", "1234567890");
      fail("CamelExecutionException expected");
    } catch (CamelExecutionException e) {
      assertEquals("TestException!!!", e.getCause().getMessage());
    }
    producerTemplate.sendBody("direct:start", "1234567890-1");

    MockEndpoint.assertIsSatisfied(consumerContext);
    MockEndpoint.assertIsSatisfied(producerContext);
  }
 @Override
 protected CamelContext createCamelContext() throws Exception {
   CamelContext context = super.createCamelContext();
   // to force a different management name than the camel id
   context.getManagementNameStrategy().setNamePattern("19-#name#");
   return context;
 }