org.apache.ignite.stream.camel.CamelStreamer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ignite-camel Show documentation
Java-based middleware for in-memory processing of big data in a distributed environment.
There is a newer version: 2.9.1
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF 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 org.apache.ignite.stream.camel;

import java.util.Map;

import org.apache.camel.CamelContext;
import org.apache.camel.Consumer;
import org.apache.camel.Endpoint;
import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.ServiceStatus;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.util.CamelContextHelper;
import org.apache.camel.util.ServiceHelper;
import org.apache.ignite.IgniteException;
import org.apache.ignite.IgniteLogger;
import org.apache.ignite.internal.util.typedef.internal.A;
import org.apache.ignite.internal.util.typedef.internal.U;
import org.apache.ignite.stream.StreamAdapter;
import org.apache.ignite.stream.StreamMultipleTupleExtractor;
import org.apache.ignite.stream.StreamSingleTupleExtractor;

/**
 * This streamer consumes messages from an Apache Camel consumer endpoint and feeds them into an Ignite data streamer.
 *
 * The only mandatory properties are {@link #endpointUri} and the appropriate stream tuple extractor (either {@link
 * StreamSingleTupleExtractor} or {@link StreamMultipleTupleExtractor}.
 *
 * The user can also provide a custom {@link CamelContext} in case they want to attach custom components, a {@link
 * org.apache.camel.component.properties.PropertiesComponent}, set tracers, management strategies, etc.
 *
 * @see Apache Camel
 * @see Apache Camel components
 */
public class CamelStreamer extends StreamAdapter implements Processor {
    /** Logger. */
    private IgniteLogger log;

    /** The Camel Context. */
    private CamelContext camelCtx;

    /** The endpoint URI to consume from. */
    private String endpointUri;

    /** Camel endpoint. */
    private Endpoint endpoint;

    /** Camel consumer. */
    private Consumer consumer;

    /** A {@link Processor} to generate the response. */
    private Processor resProc;

    /**
     * Starts the streamer.
     *
     * @throws IgniteException In cases when failed to start the streamer.
     */
    public void start() throws IgniteException {
        // Ensure that the endpoint URI is provided.
        A.notNullOrEmpty(endpointUri, "endpoint URI must be provided");

        // Check that one and only one tuple extractor is provided.
        A.ensure(!(getSingleTupleExtractor() == null && getMultipleTupleExtractor() == null),
            "tuple extractor missing");

        // If a custom CamelContext is not provided, initialize one.
        if (camelCtx == null)
            camelCtx = new DefaultCamelContext();

        // If the Camel Context is starting or started, reject this call to start.
        if (camelCtx.getStatus() == ServiceStatus.Started || camelCtx.getStatus() == ServiceStatus.Starting)
            throw new IgniteException("Failed to start Camel streamer (CamelContext already started or starting).");

        log = getIgnite().log();

        // Instantiate the Camel endpoint.
        try {
            endpoint = CamelContextHelper.getMandatoryEndpoint(camelCtx, endpointUri);
        }
        catch (Exception e) {
            U.error(log, e);

            throw new IgniteException("Failed to start Camel streamer [errMsg=" + e.getMessage() + ']');
        }

        // Create the Camel consumer.
        try {
            consumer = endpoint.createConsumer(this);
        }
        catch (Exception e) {
            U.error(log, e);

            throw new IgniteException("Failed to start Camel streamer [errMsg=" + e.getMessage() + ']');
        }

        // Start the Camel services.
        try {
            ServiceHelper.startServices(camelCtx, endpoint, consumer);
        }
        catch (Exception e) {
            U.error(log, e);

            try {
                ServiceHelper.stopAndShutdownServices(camelCtx, endpoint, consumer);

                consumer = null;
                endpoint = null;
            }
            catch (Exception e1) {
                throw new IgniteException("Failed to start Camel streamer; failed to stop the context, endpoint or " +
                    "consumer during rollback of failed initialization [errMsg=" + e.getMessage() + ", stopErrMsg=" +
                    e1.getMessage() + ']');
            }

            throw new IgniteException("Failed to start Camel streamer [errMsg=" + e.getMessage() + ']');
        }

        U.log(log, "Started Camel streamer consuming from endpoint URI: " + endpointUri);
    }

    /**
     * Stops the streamer.
     *
     * @throws IgniteException In cases if failed to stop the streamer.
     */
    public void stop() throws IgniteException {
        // If the Camel Context is stopping or stopped, reject this call to stop.
        if (camelCtx.getStatus() == ServiceStatus.Stopped || camelCtx.getStatus() == ServiceStatus.Stopping)
            throw new IgniteException("Failed to stop Camel streamer (CamelContext already stopped or stopping).");

        // Stop Camel services.
        try {
            ServiceHelper.stopAndShutdownServices(camelCtx, endpoint, consumer);
        }
        catch (Exception e) {
            throw new IgniteException("Failed to stop Camel streamer [errMsg=" + e.getMessage() + ']');
        }

        U.log(log, "Stopped Camel streamer, formerly consuming from endpoint URI: " + endpointUri);
    }

    /**
     * Processes the incoming {@link Exchange} and adds the tuple(s) to the underlying streamer.
     *
     * @param exchange The Camel Exchange.
     */
    @Override public void process(Exchange exchange) throws Exception {
        // Extract and insert the tuple(s).
        if (getMultipleTupleExtractor() == null) {
            Map.Entry entry = getSingleTupleExtractor().extract(exchange);
            getStreamer().addData(entry);
        }
        else {
            Map entries = getMultipleTupleExtractor().extract(exchange);
            getStreamer().addData(entries);
        }

        // If the user has set a response processor, invoke it before finishing.
        if (resProc != null)
            resProc.process(exchange);
    }

    /**
     * Gets the underlying {@link CamelContext}, whether created automatically by Ignite or the context specified by the
     * user.
     *
     * @return The Camel Context.
     */
    public CamelContext getCamelContext() {
        return camelCtx;
    }

    /**
     * Explicitly sets the {@link CamelContext} to use.
     *
     * Doing so gives the user the opportunity to attach custom components, a {@link
     * org.apache.camel.component.properties.PropertiesComponent}, set tracers, management strategies, etc.
     *
     * @param camelCtx The Camel Context to use. In most cases, an instance of {@link DefaultCamelContext}.
     */
    public void setCamelContext(CamelContext camelCtx) {
        this.camelCtx = camelCtx;
    }

    /**
     * Gets the endpoint URI from which to consume.
     *
     * @return The endpoint URI.
     */
    public String getEndpointUri() {
        return endpointUri;
    }

    /**
     * Sets the endpoint URI from which to consume. Mandatory.
     *
     * @param endpointUri The endpoint URI.
     */
    public void setEndpointUri(String endpointUri) {
        this.endpointUri = endpointUri;
    }

    /**
     * Gets the {@link Processor} used to generate the response.
     *
     * @return The {@link Processor}.
     */
    public Processor getResponseProcessor() {
        return resProc;
    }

    /**
     * Sets the {@link Processor} used to generate the response.
     *
     * @param resProc The {@link Processor}.
     */
    public void setResponseProcessor(Processor resProc) {
        this.resProc = resProc;
    }
}