com.qmetric.feed.consumer.EntryConsumerImpl Maven / Gradle / Ivy

Go to download
package com.qmetric.feed.consumer;

import com.github.rholder.retry.RetryException;
import com.github.rholder.retry.RetryerBuilder;
import com.qmetric.feed.consumer.store.AlreadyConsumingException;
import com.qmetric.feed.consumer.store.ConsumedStore;
import com.theoryinpractise.halbuilder.api.ReadableRepresentation;

import java.util.Collection;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;

import static com.github.rholder.retry.StopStrategies.stopAfterAttempt;
import static com.github.rholder.retry.WaitStrategies.fixedWait;
import static java.util.concurrent.TimeUnit.SECONDS;

public class EntryConsumerImpl implements EntryConsumer
{
    private static final RetryerBuilder RETRY_BUILDER = RetryerBuilder.newBuilder() //
            .retryIfException() //
            .withWaitStrategy(fixedWait(1, SECONDS)) //
            .withStopStrategy(stopAfterAttempt(60));

    private final ConsumedStore consumedStore;

    private final ConsumeAction consumeAction;

    private final Collection listeners;

    public EntryConsumerImpl(final ConsumedStore consumedStore, final ConsumeAction consumeAction, final Collection listeners)
    {
        this.consumedStore = consumedStore;
        this.consumeAction = consumeAction;
        this.listeners = listeners;
    }

    @Override
    public void consume(ReadableRepresentation feedEntry) throws Exception
    {
        markAsConsuming(feedEntry);

        process(feedEntry);

        markAsConsumed(feedEntry);

        notifyAllListeners(feedEntry);
    }

    private void markAsConsuming(final ReadableRepresentation feedEntry) throws AlreadyConsumingException
    {
        consumedStore.markAsConsuming(feedEntry);
    }

    private void process(final ReadableRepresentation feedEntry) throws Exception
    {
        try
        {
            consumeAction.consume(feedEntry);
        }
        catch (final Exception e)
        {
            consumedStore.revertConsuming(feedEntry);

            throw e;
        }
    }

    private void markAsConsumed(final ReadableRepresentation feedEntry) throws ExecutionException, RetryException
    {
        RETRY_BUILDER.build().call(new Callable()
        {
            @Override public Void call() throws Exception
            {
                consumedStore.markAsConsumed(feedEntry);
                return null;
            }
        });
    }

    private void notifyAllListeners(final ReadableRepresentation consumedEntry)
    {
        for (final EntryConsumerListener listener : listeners)
        {
            listener.consumed(consumedEntry);
        }
    }
}