public static Language getLanguage(CamelContext context) { String languageName = "jsonpath"; Language answer = context.resolveLanguage(languageName); Objects.requireNonNull(answer, "The language `" + languageName + "` cound not be resolved!"); return answer; } }
public static Language getLanguage(CamelContext context) { String languageName = "jsonpath"; Language answer = context.resolveLanguage(languageName); Objects.requireNonNull(answer, "The language `" + languageName + "` cound not be resolved!"); return answer; } }
public JsonSimplePredicate(String expression, CamelContext context) { this.language = context.resolveLanguage("simple"); this.expression = expression; Objects.requireNonNull(language, "The language 'simple' could not be resolved!"); }
static ExpressionDefinition[] getExpressionDefinitions(CamelContext context, String[] expressionStrings) { ExpressionDefinition[] result = null; if (expressionStrings != null) { String languageToUse = "simple"; int start = 0; if (expressionStrings.length > 1) { //see if the first one is a language definition String lang = expressionStrings[0].toLowerCase().trim(); if (context.resolveLanguage(lang) != null) { languageToUse = lang; start = 1; } } result = new ExpressionDefinition[expressionStrings.length - start]; for (int i = start; i < expressionStrings.length; i++) { result[i - start] = new LanguageExpression(languageToUse, expressionStrings[i]); } } return result; }
protected void testLanguage(String mainFeature, String language) throws Exception { LOG.info("Looking up CamelContext(myCamel) in OSGi Service Registry"); installCamelFeature(mainFeature); CamelContext camelContext = getOsgiService(bundleContext, CamelContext.class, "(camel.context.name=myCamel)", 20000); assertNotNull("Cannot find CamelContext with name myCamel", camelContext); LOG.info("Getting Camel language: {}", language); Language lan = camelContext.resolveLanguage(language); assertNotNull("Cannot get language with name: " + language, lan); LOG.info("Found Camel language: {} instance: {} with className: {}", language, lan, lan.getClass()); }
/** * Parses a string of the form "languageName.remaining = expression" returning the Predicate and the remaining text */ protected Pair<Predicate, String> parsePredicateAndRemaining(CamelContextService camelContextService, String key, String expression) { // lets assume no dots in language names int idx = key.indexOf('.'); if (idx > 0) { String languageName = key.substring(0, idx); String remaining = key.substring(idx + 1); Language language = camelContextService.getCamelContext().resolveLanguage(languageName); if (languageName == null) { LOG.error("Could not resolve language '" + languageName + "' with expression '" + expression + "'"); } else { try { Predicate predicate = language.createPredicate(expression); if (predicate == null) { LOG.error("Could not create predicate for language " + language + " and expression '" + expression + "'"); } else { return new Pair<Predicate, String>(predicate, remaining); } } catch (Exception e) { LOG.error("Failed to parse " + language + " expression '" + expression + "'. Reason: " + e); } } } return null; }
public JsonSimplePredicate(final String expression, final CamelContext context) { final Language language = ObjectHelper.notNull(context.resolveLanguage("simple"), "simple language"); final String ognlExpression = convertSimpleToOGNLForMaps(expression); predicate = language.createPredicate(expression); ognlPredicate = language.createPredicate(ognlExpression); final Registry registry = context.getRegistry(); final Set<ObjectMapper> mappers = registry.findByType(ObjectMapper.class); if (mappers.size() != 1) { mapper = MAPPER; } else { mapper = mappers.iterator().next(); } }
protected Language validateLanguage() { ObjectHelper.notNull(camelContext, "camelContext"); ObjectHelper.notNull(language, "language"); ObjectHelper.notNull(expression, "expression"); Language languageImpl = camelContext.resolveLanguage(language); ObjectHelper.notNull(languageImpl, "language " + language + " could not be resolved"); return languageImpl; }
public JsonSimplePredicate(String expression, CamelContext context) { Language language = ObjectHelper.notNull(context.resolveLanguage("simple"), "simple language"); String ognlExpression = convertSimpleToOGNLForMaps(expression); this.predicate = language.createPredicate(expression); this.ognlPredicate = language.createPredicate(ognlExpression); }
@Override public Optional<ProcessorDefinition> handle(SplitInline step, ProcessorDefinition route, SyndesisRouteBuilder routeBuilder) { String languageName = step.getLanguage(); String expressionDefinition = step.getExpression(); if (ObjectHelper.isEmpty(languageName) && ObjectHelper.isEmpty(expressionDefinition)) { return Optional.of(route.split(Builder.body())); } else { Objects.requireNonNull(languageName, "Expression language should not be null"); Objects.requireNonNull(expressionDefinition, "Expression should not be null"); // A small hack until https://issues.apache.org/jira/browse/CAMEL-12079 // gets fixed so we can support the 'bean::method' annotation as done by // Function step definition if ("bean".equals(languageName)) { if (expressionDefinition.contains("::")) { expressionDefinition = expressionDefinition.replace("::", "?method="); } } final CamelContext context = routeBuilder.getContext(); final Language language = context.resolveLanguage(languageName); final Expression expression = language.createExpression(expressionDefinition); final ProcessorDefinition split = route.split(expression); return Optional.of(split); } } }
@SuppressWarnings("unchecked") private Script instantiateScript(Exchange exchange) { // Get the script from the cache, or create a new instance GroovyLanguage language = (GroovyLanguage) exchange.getContext().resolveLanguage("groovy"); Class<Script> scriptClass = language.getScriptFromCache(text); if (scriptClass == null) { GroovyShell shell; Set<GroovyShellFactory> shellFactories = exchange.getContext().getRegistry().findByType(GroovyShellFactory.class); if (shellFactories.size() > 1) { throw new IllegalStateException("Too many GroovyShellFactory instances found: " + shellFactories.size()); } else if (shellFactories.size() == 1) { shell = shellFactories.iterator().next().createGroovyShell(exchange); } else { ClassLoader cl = exchange.getContext().getApplicationContextClassLoader(); shell = cl != null ? new GroovyShell(cl) : new GroovyShell(); } scriptClass = shell.getClassLoader().parseClass(text); language.addScriptToCache(text, scriptClass); } // New instance of the script try { return scriptClass.newInstance(); } catch (InstantiationException e) { throw new RuntimeCamelException(e); } catch (IllegalAccessException e) { throw new RuntimeCamelException(e); } }
Language expLang = exchange.getContext().resolveLanguage(getLanguagePart()); String scheme = getSchemePart(); if (scheme != null && (scheme.equalsIgnoreCase("classpath") || scheme.equalsIgnoreCase("file") || scheme.equalsIgnoreCase("http"))) {
Object answer; if (path == null) { Expression exp = exchange.getContext().resolveLanguage("simple").createExpression(expression); String text = exp.evaluate(exchange, String.class); JsonPath path = JsonPath.compile(text);
@Lazy @Bean(name = ServiceCallDefinitionConstants.DEFAULT_SERVICE_CALL_CONFIG_ID) @ConditionalOnMissingBean(name = ServiceCallDefinitionConstants.DEFAULT_SERVICE_CALL_CONFIG_ID) public ServiceCallConfigurationDefinition serviceCallConfiguration() throws Exception { final ServiceCallConfigurationDefinition definition = new ServiceCallConfigurationDefinition(); final CamelCloudConfigurationProperties.ServiceCall serviceCall = configurationProperties.getServiceCall(); ObjectHelper.ifNotEmpty(serviceCall.getComponent(), definition::setComponent); ObjectHelper.ifNotEmpty(serviceCall.getUri(), definition::setUri); ObjectHelper.ifNotEmpty(serviceCall.getServiceDiscovery(), definition::setServiceDiscoveryRef); ObjectHelper.ifNotEmpty(serviceCall.getServiceFilter(), definition::setServiceFilterRef); ObjectHelper.ifNotEmpty(serviceCall.getServiceChooser(), definition::setServiceChooserRef); ObjectHelper.ifNotEmpty(serviceCall.getLoadBalancer(), definition::setLoadBalancerRef); if (serviceCall.getLoadBalancer() == null && serviceCall.isDefaultLoadBalancer()) { definition.defaultLoadBalancer(); } final String expression = serviceCall.getExpression(); final String expressionLanguage = serviceCall.getExpressionLanguage(); if (ObjectHelper.isNotEmpty(expression) && ObjectHelper.isNotEmpty(expressionLanguage)) { Language language = camelContext.resolveLanguage(expressionLanguage); if (language == null) { throw new IllegalArgumentException("Unable to resolve language: " + expressionLanguage); } definition.setExpression(language.createExpression(expression)); } return definition; }