io.siddhi.core.util.SiddhiAppRuntimeBuilder Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
 *
 * WSO2 Inc. licenses this file to you under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package io.siddhi.core.util;

import io.siddhi.core.SiddhiAppRuntime;
import io.siddhi.core.SiddhiAppRuntimeImpl;
import io.siddhi.core.aggregation.AggregationRuntime;
import io.siddhi.core.config.SiddhiAppContext;
import io.siddhi.core.exception.SiddhiAppCreationException;
import io.siddhi.core.partition.PartitionRuntime;
import io.siddhi.core.partition.PartitionRuntimeImpl;
import io.siddhi.core.query.QueryRuntime;
import io.siddhi.core.query.QueryRuntimeImpl;
import io.siddhi.core.query.input.ProcessStreamReceiver;
import io.siddhi.core.query.input.stream.StreamRuntime;
import io.siddhi.core.query.input.stream.single.SingleStreamRuntime;
import io.siddhi.core.query.output.callback.InsertIntoStreamCallback;
import io.siddhi.core.query.output.callback.InsertIntoWindowCallback;
import io.siddhi.core.query.output.callback.OutputCallback;
import io.siddhi.core.stream.StreamJunction;
import io.siddhi.core.stream.input.InputManager;
import io.siddhi.core.stream.input.source.Source;
import io.siddhi.core.stream.output.sink.Sink;
import io.siddhi.core.table.Table;
import io.siddhi.core.trigger.Trigger;
import io.siddhi.core.util.lock.LockSynchronizer;
import io.siddhi.core.util.parser.AggregationParser;
import io.siddhi.core.util.parser.helper.DefinitionParserHelper;
import io.siddhi.core.window.Window;
import io.siddhi.query.api.definition.AbstractDefinition;
import io.siddhi.query.api.definition.AggregationDefinition;
import io.siddhi.query.api.definition.FunctionDefinition;
import io.siddhi.query.api.definition.StreamDefinition;
import io.siddhi.query.api.definition.TableDefinition;
import io.siddhi.query.api.definition.TriggerDefinition;
import io.siddhi.query.api.definition.WindowDefinition;

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * For building SiddhiAppRuntime
 */
public class SiddhiAppRuntimeBuilder {
    private ConcurrentMap streamDefinitionMap =
            new ConcurrentHashMap(); //contains stream definition
    private ConcurrentMap tableDefinitionMap =
            new ConcurrentHashMap(); //contains table definition
    private ConcurrentMap windowDefinitionMap =
            new ConcurrentHashMap(); //contains window definition
    private ConcurrentMap aggregationDefinitionMap =
            new ConcurrentHashMap(); //contains aggregation definition
    private ConcurrentMap triggerDefinitionMap =
            new ConcurrentHashMap(); //contains trigger definition
    private Map queryProcessorMap =
            Collections.synchronizedMap(new LinkedHashMap());  //contains query processors
    private ConcurrentMap streamJunctionMap =
            new ConcurrentHashMap(); //contains stream junctions
    private ConcurrentMap> sourceMap =
            new ConcurrentHashMap>(); //contains sources
    private ConcurrentMap> sinkMap =
            new ConcurrentHashMap>(); //contains sinks
    private ConcurrentMap tableMap =
            new ConcurrentHashMap(); //contains tables
    private ConcurrentMap windowMap =
            new ConcurrentHashMap(); //contains windows
    private ConcurrentMap aggregationMap =
            new ConcurrentHashMap(); //contains aggregation runtime
    private ConcurrentMap triggerMap =
            new ConcurrentHashMap(); //contains triggers
    private ConcurrentMap partitionMap =
            new ConcurrentHashMap(); //contains partitions
    private ConcurrentMap siddhiAppRuntimeMap = null;
    private SiddhiAppContext siddhiAppContext;
    private InputManager inputManager;
    private LockSynchronizer lockSynchronizer = new LockSynchronizer();

    public SiddhiAppRuntimeBuilder(SiddhiAppContext siddhiAppContext) {
        this.siddhiAppContext = siddhiAppContext;
        this.inputManager = new InputManager(this.siddhiAppContext, streamDefinitionMap, streamJunctionMap, tableMap);
    }

    public void defineStream(StreamDefinition streamDefinition) {
        DefinitionParserHelper.validateDefinition(streamDefinition, streamDefinitionMap, tableDefinitionMap,
                windowDefinitionMap, aggregationDefinitionMap);
        AbstractDefinition currentDefinition = streamDefinitionMap
                .putIfAbsent(streamDefinition.getId(), streamDefinition);
        if (currentDefinition != null) {
            streamDefinition = (StreamDefinition) currentDefinition;
        }
        try {
            DefinitionParserHelper.addStreamJunction(streamDefinition, streamJunctionMap, siddhiAppContext);
        } catch (Throwable t) {
            ExceptionUtil.populateQueryContext(t, streamDefinition, siddhiAppContext);
            throw t;
        }
        DefinitionParserHelper.addEventSource(streamDefinition, sourceMap, siddhiAppContext);
        StreamJunction streamJunction = streamJunctionMap.get(streamDefinition.getId());
        DefinitionParserHelper.addEventSink(streamDefinition, streamJunction, sinkMap, siddhiAppContext);
    }

    public void defineTable(TableDefinition tableDefinition) {
        DefinitionParserHelper.validateDefinition(tableDefinition, streamDefinitionMap, tableDefinitionMap,
                windowDefinitionMap, aggregationDefinitionMap);
        AbstractDefinition currentDefinition = tableDefinitionMap.putIfAbsent(tableDefinition.getId(), tableDefinition);
        if (currentDefinition != null) {
            tableDefinition = (TableDefinition) currentDefinition;
        }
        DefinitionParserHelper.addTable(tableDefinition, tableMap, siddhiAppContext);
    }

    public void defineWindow(WindowDefinition windowDefinition) {
        DefinitionParserHelper.validateDefinition(windowDefinition, streamDefinitionMap, tableDefinitionMap,
                windowDefinitionMap, aggregationDefinitionMap);
        DefinitionParserHelper.addStreamJunction(windowDefinition, streamJunctionMap, siddhiAppContext);
        AbstractDefinition currentDefinition = windowDefinitionMap
                .putIfAbsent(windowDefinition.getId(), windowDefinition);
        if (currentDefinition != null) {
            windowDefinition = (WindowDefinition) currentDefinition;
        }
        DefinitionParserHelper.addWindow(windowDefinition, windowMap, siddhiAppContext);
    }

    public void defineTrigger(TriggerDefinition triggerDefinition) {
        DefinitionParserHelper.validateDefinition(triggerDefinition);
        TriggerDefinition currentDefinition = triggerDefinitionMap.putIfAbsent(triggerDefinition.getId(),
                triggerDefinition);
        if (currentDefinition != null) {
            triggerDefinition = currentDefinition;
        }
        DefinitionParserHelper.addEventTrigger(triggerDefinition, triggerMap, streamJunctionMap,
                siddhiAppContext);
    }

    public void defineAggregation(AggregationDefinition aggregationDefinition) {
        AggregationRuntime aggregationRuntime = AggregationParser.parse(aggregationDefinition, siddhiAppContext,
                streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap,
                windowMap, aggregationMap, this);
        DefinitionParserHelper.validateDefinition(aggregationDefinition, streamDefinitionMap, tableDefinitionMap,
                windowDefinitionMap, aggregationDefinitionMap);
        aggregationDefinitionMap.putIfAbsent(aggregationDefinition.getId(), aggregationDefinition);
        ProcessStreamReceiver processStreamReceiver = aggregationRuntime.getSingleStreamRuntime().
                getProcessStreamReceiver();
        streamJunctionMap.get(processStreamReceiver.getStreamId()).subscribe(processStreamReceiver);
        aggregationMap.putIfAbsent(aggregationDefinition.getId(), aggregationRuntime);
    }

    public void addPartition(PartitionRuntimeImpl partitionRuntime) {
        partitionMap.put(partitionRuntime.getPartitionName(), partitionRuntime);
    }

    public String addQuery(QueryRuntimeImpl queryRuntime) {
        QueryRuntime oldQueryRuntime = queryProcessorMap.put(queryRuntime.getQueryId(), queryRuntime);
        if (oldQueryRuntime != null) {
            throw new SiddhiAppCreationException("Multiple queries with name '" + queryRuntime.getQueryId() +
                    "' defined in Siddhi App '" + siddhiAppContext.getName() + "'",
                    queryRuntime.getQuery().getQueryContextStartIndex(),
                    queryRuntime.getQuery().getQueryContextEndIndex());
        }
        StreamRuntime streamRuntime = queryRuntime.getStreamRuntime();

        for (SingleStreamRuntime singleStreamRuntime : streamRuntime.getSingleStreamRuntimes()) {
            ProcessStreamReceiver processStreamReceiver = singleStreamRuntime.getProcessStreamReceiver();
            if (processStreamReceiver.toStream()) {
                StreamJunction streamJunction = streamJunctionMap.get(processStreamReceiver.getStreamId());
                if (streamJunction != null) {
                    streamJunction.subscribe(processStreamReceiver);
                } else {
                    throw new SiddhiAppCreationException("Expecting a stream, but provided '"
                            + processStreamReceiver.getStreamId() + "' is not a stream");
                }
            }
        }
        OutputCallback outputCallback = queryRuntime.getOutputCallback();

        if (outputCallback != null && outputCallback instanceof InsertIntoStreamCallback) {
            InsertIntoStreamCallback insertIntoStreamCallback = (InsertIntoStreamCallback) outputCallback;
            StreamDefinition streamDefinition = insertIntoStreamCallback.getOutputStreamDefinition();
            streamDefinitionMap.putIfAbsent(streamDefinition.getId(), streamDefinition);
            DefinitionParserHelper.validateOutputStream(streamDefinition,
                    streamDefinitionMap.get(streamDefinition.getId()));
            StreamJunction outputStreamJunction = streamJunctionMap.get(streamDefinition.getId());

            if (outputStreamJunction == null) {
                outputStreamJunction = new StreamJunction(streamDefinition,
                        siddhiAppContext.getExecutorService(),
                        siddhiAppContext.getBufferSize(), null, siddhiAppContext);
                streamJunctionMap.putIfAbsent(streamDefinition.getId(), outputStreamJunction);
            }
            insertIntoStreamCallback.init(streamJunctionMap.get(insertIntoStreamCallback.getOutputStreamDefinition()
                    .getId()));
        } else if (outputCallback != null && outputCallback instanceof InsertIntoWindowCallback) {
            InsertIntoWindowCallback insertIntoWindowCallback = (InsertIntoWindowCallback) outputCallback;
            StreamDefinition streamDefinition = insertIntoWindowCallback.getOutputStreamDefinition();
            windowDefinitionMap.putIfAbsent(streamDefinition.getId(), streamDefinition);
            DefinitionParserHelper.validateOutputStream(streamDefinition, windowDefinitionMap.get(streamDefinition
                    .getId()));
            StreamJunction outputStreamJunction = streamJunctionMap.get(streamDefinition.getId());

            if (outputStreamJunction == null) {
                outputStreamJunction = new StreamJunction(streamDefinition,
                        siddhiAppContext.getExecutorService(),
                        siddhiAppContext.getBufferSize(), null, siddhiAppContext);
                streamJunctionMap.putIfAbsent(streamDefinition.getId(), outputStreamJunction);
            }
            insertIntoWindowCallback.getWindow().setPublisher(streamJunctionMap.get(insertIntoWindowCallback
                    .getOutputStreamDefinition().getId()).constructPublisher());
        }

        return queryRuntime.getQueryId();
    }

    public void defineFunction(FunctionDefinition functionDefinition) {
        DefinitionParserHelper.addFunction(siddhiAppContext, functionDefinition);
    }

    public void setSiddhiAppRuntimeMap(ConcurrentMap siddhiAppRuntimeMap) {
        this.siddhiAppRuntimeMap = siddhiAppRuntimeMap;
    }

    public ConcurrentMap getStreamJunctions() {
        return streamJunctionMap;
    }

    public ConcurrentMap getTableMap() {
        return tableMap;
    }

    public ConcurrentMap getWindowMap() {
        return windowMap;
    }

    public ConcurrentMap getAggregationMap() {
        return aggregationMap;
    }

    public ConcurrentMap getStreamDefinitionMap() {
        return streamDefinitionMap;
    }

    public ConcurrentMap getTableDefinitionMap() {
        return tableDefinitionMap;
    }

    public ConcurrentMap> getSourceMap() {
        return sourceMap;
    }

    public ConcurrentMap> getSinkMap() {
        return sinkMap;
    }

    public ConcurrentMap getWindowDefinitionMap() {
        return windowDefinitionMap;
    }

    public ConcurrentMap getAggregationDefinitionMap() {
        return aggregationDefinitionMap;
    }

    public LockSynchronizer getLockSynchronizer() {
        return lockSynchronizer;
    }

    public SiddhiAppRuntime build() {
        return new SiddhiAppRuntimeImpl(streamDefinitionMap, tableDefinitionMap, windowDefinitionMap,
                aggregationDefinitionMap, inputManager, queryProcessorMap, streamJunctionMap, tableMap, windowMap,
                aggregationMap, sourceMap, sinkMap, partitionMap, triggerMap,
                siddhiAppContext, siddhiAppRuntimeMap);
    }

}