@SuppressWarnings({"unchecked"}) private DataType<?> getEventType(EventStream stream, ClassLoader loader) throws ClassNotFoundException { Class<?> type; List<String> eventTypes = stream.getDefinition().getEventTypes(); if (eventTypes.isEmpty()) { // default to Object if there are no event types type = Object.class; } else { type = ParameterTypeHelper.loadClass(eventTypes.get(0), loader); } return new JavaClass(type); }
private PhysicalEventStreamDefinition generateEventStream(LogicalConsumer consumer) { PhysicalEventStreamDefinition definition = new PhysicalEventStreamDefinition("default"); List<DataType<?>> types = consumer.getDefinition().getTypes(); boolean typed = false; boolean takesChannelEvent = false; for (DataType<?> dataType : types) { if (dataType instanceof JavaType) { // for now only support Java contracts if (!Object.class.equals(dataType.getLogical())) { typed = true; if (ChannelEvent.class.isAssignableFrom(dataType.getPhysical())) { takesChannelEvent = true; } } } definition.setChannelEvent(takesChannelEvent); definition.addEventType(dataType.getPhysical().getName()); } if (typed) { TypeEventFilterDefinition typeFilter = new TypeEventFilterDefinition(types); definition.addFilterDefinition(typeFilter); } return definition; }
/** * Adds event filters if they are defined for the stream. * * @param streamDefinition the stream definition * @param stream the stream being created * @throws BuilderException if there is an error adding a filter */ @SuppressWarnings({"unchecked"}) private void addFilters(PhysicalEventStreamDefinition streamDefinition, EventStream stream) throws BuilderException { for (PhysicalEventFilterDefinition definition : streamDefinition.getFilters()) { EventFilterBuilder builder = filterBuilders.get(definition.getClass()); EventFilter filter = builder.build(definition); FilterHandler handler = new FilterHandler(filter); stream.addHandler(handler); } }
private PhysicalEventStreamDefinition generate(LogicalOperation operation) { Operation o = operation.getDefinition(); PhysicalEventStreamDefinition definition = new PhysicalEventStreamDefinition(o.getName()); definition.setName(o.getName()); List<DataType<?>> params = o.getInputTypes(); for (DataType<?> param : params) { Class<?> paramType = param.getPhysical(); String paramName = paramType.getName(); definition.addEventType(paramName); } return definition; }
/** * Adds event stream handlers if they are defined for the stream. * * @param streamDefinition the stream definition * @param stream the stream being created * @throws BuilderException if there is an error adding a handler */ @SuppressWarnings({"unchecked"}) private void addHandlers(PhysicalEventStreamDefinition streamDefinition, EventStream stream) throws BuilderException { for (PhysicalHandlerDefinition definition : streamDefinition.getHandlers()) { EventStreamHandlerBuilder builder = handlerBuilders.get(definition.getClass()); EventStreamHandler handler = builder.build(definition); stream.addHandler(handler); } }
private void generatePolicy(LogicalConsumer consumer, PhysicalEventStreamDefinition eventStream) throws GenerationException { PolicyResult result = resolver.resolvePolicies(consumer); if (result.getInterceptedPolicySets().isEmpty()) { return; } List<PolicySet> policies = result.getInterceptedPolicySets().values().iterator().next(); PolicyMetadata metadata = result.getMetadata().values().iterator().next(); for (PolicySet set : policies) { QName expressionName = set.getExpressionName(); EventStreamHandlerGenerator handlerGenerator = generatorRegistry.getEventStreamHandlerGenerator(expressionName); PhysicalHandlerDefinition definition = handlerGenerator.generate(set.getExpression(), metadata); if (definition != null) { definition.setPolicyClassLoaderId(set.getContributionUri()); eventStream.addHandlerDefinition(definition); } } }
public void onEvent(RingBufferEvent event, long sequence, boolean endOfBatch) throws Exception { if (stream.getDefinition().isChannelEvent()) { // consumer takes a channel event, send that, making sure to set the end-of-batch marker and sequence number event.setEndOfBatch(endOfBatch); event.setSequence(sequence); stream.getHeadHandler().handle(event, endOfBatch); } else { // if the parsed value has been set, send that Object parsed = event.getParsed(Object.class); if (parsed != null) { stream.getHeadHandler().handle(parsed, endOfBatch); } else { stream.getHeadHandler().handle(event.getEvent(Object.class), endOfBatch); } } } }
@SuppressWarnings({"unchecked"}) private DataType<?> getEventTypeForConnection(ChannelConnection connection, ClassLoader loader) throws BrokerException { PhysicalEventStreamDefinition eventStreamDefinition = connection.getEventStream().getDefinition(); if (!eventStreamDefinition.getEventTypes().isEmpty()) { try { String eventType = eventStreamDefinition.getEventTypes().get(0); Class<?> type = ParameterTypeHelper.loadClass(eventType, loader); return new JavaClass(type); } catch (ClassNotFoundException e) { throw new BrokerException(e); } } else { return new JavaClass<Object>(Object.class); } }
/** * Adds event transformers to convert an event from one format to another. * * @param streamDefinition the stream definition * @param stream the stream being created * @param loader the target classloader to use for the transformation * @throws BuilderException if there is an error adding a filter */ @SuppressWarnings({"unchecked"}) private void addTransformer(PhysicalEventStreamDefinition streamDefinition, EventStream stream, ClassLoader loader) throws BuilderException { if (transformerRegistry == null) { // no transformer registry configured (e.g. during bootstrap) so skip return; } List<String> eventTypes = streamDefinition.getEventTypes(); String stringifiedType = eventTypes.get(0); try { DataType<Object> type = new JavaClass(loader.loadClass(stringifiedType)); TransformerHandler handler = new TransformerHandler(type, transformerRegistry); stream.addHandler(handler); } catch (ClassNotFoundException e) { throw new BuilderException(e); } }