Refine search
private void createTransformerFactory() throws ClassNotFoundException { // provide the class loader of this component to work in OSGi environments Class<TransformerFactory> factoryClass = getCamelContext().getClassResolver().resolveMandatoryClass(SAXON_TRANSFORMER_FACTORY_CLASS_NAME, TransformerFactory.class, SchematronComponent.class.getClassLoader()); LOG.debug("Using TransformerFactoryClass {}", factoryClass); transformerFactory = getCamelContext().getInjector().newInstance(factoryClass); transformerFactory.setURIResolver(new ClassPathURIResolver(Constants.SCHEMATRON_TEMPLATES_ROOT_DIR, this.uriResolver)); transformerFactory.setAttribute(LINE_NUMBERING, true); }
private ComponentProxyCustomizer resolveCustomizer(CamelContext context, String customizerType) { Class<ComponentProxyCustomizer> type = context.getClassResolver().resolveClass(customizerType, ComponentProxyCustomizer.class); if (type == null) { throw new IllegalArgumentException("Unable to resolve a ComponentProxyCustomizer of type: " + customizerType); } final ComponentProxyCustomizer customizer = context.getInjector().newInstance(type); if (customizer == null) { throw new IllegalArgumentException("Unable to instantiate a ComponentProxyCustomizer of type: " + customizerType); } return customizer; } }
@Override public InputStream getInputStream() throws IOException { return resolver.loadResourceAsStream(path); }
@SuppressWarnings("PMD") @Override public Optional<ProcessorDefinition<?>> handle(io.syndesis.common.model.integration.Step step, ProcessorDefinition<?> route, IntegrationRouteBuilder builder, String flowIndex, String stepIndex) { ObjectHelper.notNull(route, "route"); String options = null; if (ObjectHelper.isEmpty(function)) { return Optional.empty(); if (ObjectHelper.isNotEmpty(properties)) { options = properties.entrySet().stream() .filter(entry -> ObjectHelper.isNotEmpty(entry.getKey())) } else if (action.getDescriptor().getKind() == StepAction.Kind.STEP) { final String target = action.getDescriptor().getEntrypoint(); final TypeConverter converter = context.getTypeConverter(); if (!ObjectHelper.isEmpty(target)) { try { final Class<Step> clazz = context.getClassResolver().resolveMandatoryClass(target, Step.class); final Step stepExtension = context.getInjector().newInstance(clazz); final Map<String, Object> props = new HashMap<>(properties);
LOG.debug("Unmarshalling input data using data format '{}'.", unmarshalId); resolveUnmarshaller(exchange, unmarshalId).process(exchange); if (exchange.getException() != null) { throw exchange.getException(); Class<?> targetModel = endpoint.getCamelContext().getClassResolver().resolveMandatoryClass( endpoint.getConfiguration().getTargetModel()); Message msg = exchange.hasOut() ? exchange.getOut() : exchange.getIn(); LOG.debug("Converting to source model {}.", sourceType); Class<?> sourceModel = endpoint.getCamelContext() .getClassResolver().resolveClass(sourceType); if (sourceModel == null) { throw new Exception("Unable to load sourceModel class: " + sourceType);
@Override public void marshal(Exchange exchange, Object graph, OutputStream stream) throws Exception { InputStream berOut = null; if (usingIterator) { if (clazzName != null) { Class<?> clazz = exchange.getContext().getClassResolver().resolveMandatoryClass(clazzName); encodeGenericTypeObject(exchange, clazz, stream); return; } Object record = exchange.getIn().getBody(); if (record instanceof ASN1Primitive) { ASN1Primitive asn1Primitive = ObjectHelper.cast(ASN1Primitive.class, record); berOut = new ByteArrayInputStream(asn1Primitive.getEncoded()); } else if (record instanceof byte[]) { berOut = new ByteArrayInputStream(ObjectHelper.cast(byte[].class, record)); } } else { byte[] byteInput = exchange.getContext().getTypeConverter().mandatoryConvertTo(byte[].class, exchange, graph); berOut = new ByteArrayInputStream(byteInput); } try { IOHelper.copy(berOut, stream); } finally { IOHelper.close(berOut, stream); } }
XMLEventReader reader; if (isNamespaceAware) { reader = exchange.getIn().getMandatoryBody(XMLEventReader.class); } else { InputStream inputStream = exchange.getIn().getMandatoryBody(InputStream.class); XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance(); xmlInputFactory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, false); clazz = (Class<T>) exchange.getContext().getClassResolver().resolveMandatoryClass(handledName);
String partClassFromHeader = exchange.getIn().getHeader(JaxbConstants.JAXB_PART_CLASS, String.class); String partNamespaceFromHeader = exchange.getIn().getHeader(JaxbConstants.JAXB_PART_NAMESPACE, String.class); if ((partialClass != null || partClassFromHeader != null) && (partNamespaceOnDataFormat != null || partNamespaceFromHeader != null)) { if (partClassFromHeader != null) { try { partialClass = camelContext.getClassResolver().resolveMandatoryClass(partClassFromHeader, Object.class); } catch (ClassNotFoundException e) { throw new JAXBException(e); LOG.debug("Attempt to marshalling non JAXBElement with type {} as InputStream", ObjectHelper.classCanonicalName(graph)); InputStream is = exchange.getContext().getTypeConverter().mandatoryConvertTo(InputStream.class, exchange, graph); IOHelper.copyAndCloseInput(is, stream); } else {
xmlReader = typeConverter.convertTo(XMLStreamReader.class, exchange, stream); String partClassFromHeader = exchange.getIn().getHeader(JaxbConstants.JAXB_PART_CLASS, String.class); if (partialClass != null || partClassFromHeader != null) { partialClass = camelContext.getClassResolver().resolveMandatoryClass(partClassFromHeader, Object.class); } catch (ClassNotFoundException e) { throw new JAXBException(e);
@Override protected Endpoint createEndpoint(String uri, String path, Map<String, Object> options) throws Exception { JpaEndpoint endpoint = new JpaEndpoint(uri, this); endpoint.setJoinTransaction(isJoinTransaction()); endpoint.setSharedEntityManager(isSharedEntityManager()); // lets interpret the next string as a class if (ObjectHelper.isNotEmpty(path)) { // provide the class loader of this component to work in OSGi environments as camel-jpa must be able // to resolve the entity classes Class<?> type = getCamelContext().getClassResolver().resolveClass(path, JpaComponent.class.getClassLoader()); if (type != null) { endpoint.setEntityType(type); } } return endpoint; }
Iterator<Object> it = ObjectHelper.createIterator(value); while (it.hasNext()) { value = (String) it.next(); if (ObjectHelper.isNotEmpty(value)) { for (Class<?> clazz : classes) { try { RouteBuilder route = (RouteBuilder) camelContext.getInjector().newInstance(clazz); builders.add(route); } catch (Exception e) { Class<RouteBuilder> clazz = camelContext.getClassResolver().resolveMandatoryClass(value, RouteBuilder.class); target = camelContext.getInjector().newInstance(clazz); } catch (Exception e) { throw new RuntimeException("Error creating RouteBuilder " + value, e);
protected XMLContext createXMLContext(ClassResolver resolver, ClassLoader contextClassLoader) throws Exception { XMLContext xmlContext = new XMLContext(); if (ObjectHelper.isNotEmpty(getMappingFile())) { Mapping xmlMap; if (contextClassLoader != null) { xmlMap = new Mapping(contextClassLoader); } else { xmlMap = new Mapping(); } xmlMap.loadMapping(resolver.loadResourceAsURL(getMappingFile())); xmlContext.addMapping(xmlMap); } if (getPackages() != null) { xmlContext.addPackages(getPackages()); } if (getClassNames() != null) { for (String name : getClassNames()) { Class<?> clazz = resolver.resolveClass(name); xmlContext.addClass(clazz); } } return xmlContext; }
@Override @SuppressWarnings("unchecked") protected void doStart() throws Exception { ObjectHelper.notNull(camelContext, "CamelContext"); if (context == null) { // if context not injected, create one and resolve partial class up front so they are ready to be used context = createContext(); } introspector = context.createJAXBIntrospector(); if (partClass != null) { partialClass = camelContext.getClassResolver().resolveMandatoryClass(partClass, Object.class); } if (namespacePrefixRef != null) { namespacePrefix = CamelContextHelper.mandatoryLookup(camelContext, namespacePrefixRef, Map.class); } if (namespacePrefix != null) { namespacePrefixMapper = NamespacePrefixMapperFactory.newNamespacePrefixMapper(camelContext, namespacePrefix); } typeConverter = camelContext.getTypeConverter(); if (schema != null) { cachedSchema = createSchema(getSources()); } LOG.debug("JaxbDataFormat [prettyPrint={}, objectFactory={}]", prettyPrint, objectFactory); }
@Override protected void doStart() throws Exception { ObjectHelper.notNull(camelContext, "camelContext"); InputStream is = camelContext.getClassResolver().loadResourceAsStream(modRewriteConfFile); if (is == null) { throw new IOException("Cannot load mod rewrite config file: " + modRewriteConfFile); String text = camelContext.getTypeConverter().mandatoryConvertTo(String.class, is); ModRewriteConfLoader loader = new ModRewriteConfLoader(); conf = new Conf(); } else if (configFile != null) { LOG.debug("Using config file: {} as config for urlRewrite", configFile); InputStream is = camelContext.getClassResolver().loadResourceAsStream(configFile); if (is == null) { throw new IOException("Cannot load config file: " + configFile);
private int setDataFieldValue(CamelContext camelContext, Map<String, Object> model, int line, int pos, int counterMandatoryFields, String data, DataField dataField) throws Exception { ObjectHelper.notNull(dataField, "No position " + pos + " defined for the field: " + data + ", line: " + line); Class<?> clazz; if (dataField.method().contains(".")) { clazz = camelContext.getClassResolver().resolveMandatoryClass(dataField.method().substring(0, dataField.method().lastIndexOf("."))); } else { clazz = field.getType(); value = ObjectHelper.invokeMethod(m, null, value); } else { value = ObjectHelper.invokeMethod(m, value);
String os = ObjectHelper.getSystemProperty("os.name", ""); if (os.toLowerCase(Locale.US).startsWith("mac")) { Class<WatchEvent.Modifier> clazz = getCamelContext().getClassResolver().resolveClass("com.sun.nio.file.SensitivityWatchEventModifier", WatchEvent.Modifier.class); if (clazz != null) { WatchEvent.Modifier[] modifiers = clazz.getEnumConstants(); executorService = getCamelContext().getExecutorServiceManager().newSingleThreadExecutor(this, "FileWatcherStrategy"); executorService.submit(task); } catch (IOException e) { throw ObjectHelper.wrapRuntimeCamelException(e);
@SuppressWarnings({"rawtypes", "unchecked"}) @Override public Object unmarshal(Exchange exchange, InputStream stream) throws Exception { if (usingIterator) { if (clazzName != null) { Class<?> clazz = exchange.getContext().getClassResolver().resolveMandatoryClass(clazzName); ASN1GenericIterator asn1GenericIterator = new ASN1GenericIterator(clazz, stream); return asn1GenericIterator; } ASN1MessageIterator asn1MessageIterator = new ASN1MessageIterator(exchange, stream); return asn1MessageIterator; } else { ASN1Primitive asn1Record = null; byte[] asn1Bytes; try (ASN1InputStream ais = new ASN1InputStream(stream); ByteArrayOutputStream asn1Out = new ByteArrayOutputStream();) { while (ais.available() > 0) { asn1Record = ais.readObject(); asn1Out.write(asn1Record.getEncoded()); } asn1Bytes = asn1Out.toByteArray(); } return asn1Bytes; } }
Object id = message.getHeader(HBaseAttribute.HBASE_ROW_ID.asHeader(index)); String rowClassName = message.getHeader(HBaseAttribute.HBASE_ROW_TYPE.asHeader(index), String.class); Class<?> rowClass = rowClassName == null || rowClassName.isEmpty() ? String.class : message.getExchange().getContext().getClassResolver().resolveClass(rowClassName); String columnFamily = (String) message.getHeader(HBaseAttribute.HBASE_FAMILY.asHeader(index)); String columnName = (String) message.getHeader(HBaseAttribute.HBASE_QUALIFIER.asHeader(index)); Class<?> valueClass = valueClassName == null || valueClassName.isEmpty() ? String.class : message.getExchange().getContext().getClassResolver().resolveClass(valueClassName);
public static DockerClient getDockerClient(DockerComponent dockerComponent, DockerConfiguration dockerConfiguration, Message message) throws DockerException { ObjectHelper.notNull(dockerConfiguration, "dockerConfiguration"); ObjectHelper.notNull(clientProfile.getCertPath(), "certPath must be specified in secure mode"); sslConfig = new LocalDirectorySSLConfig(clientProfile.getCertPath()); } else { .withConnectTimeout(clientProfile.getRequestTimeout()); } else { Class<DockerCmdExecFactory> clazz = camelContext.getClassResolver().resolveMandatoryClass(cmdExecFactory, DockerCmdExecFactory.class); factory = ObjectHelper.newInstance(clazz);
@SuppressWarnings("rawtypes") public static Class getServerInterface(String packageName, String serviceName, boolean isSyncInterface, final CamelContext context) { String serverInterfaceName = null; Class serverInterface = null; try { if (isSyncInterface) { serverInterfaceName = packageName + "." + serviceName + "$" + ThriftConstants.THRIFT_SERVER_SYNC_INTERFACE_NAME; } else { serverInterfaceName = packageName + "." + serviceName + "$" + ThriftConstants.THRIFT_SERVER_ASYNC_INTERFACE_NAME; } serverInterface = context.getClassResolver().resolveMandatoryClass(serverInterfaceName); } catch (ClassNotFoundException e) { throw new IllegalArgumentException("Unable to find server interface implementation for: " + serverInterfaceName); } return serverInterface; }