io.zeebe.logstreams.impl.LogStorageAppender Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of zb-logstreams Show documentation
There is a newer version: 0.16.4
/*
 * Copyright © 2017 camunda services GmbH ([email protected])
 *
 * Licensed 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.zeebe.logstreams.impl;

import java.nio.ByteBuffer;
import java.util.concurrent.atomic.AtomicBoolean;

import io.zeebe.dispatcher.BlockPeek;
import io.zeebe.dispatcher.Subscription;
import io.zeebe.logstreams.spi.LogStorage;
import io.zeebe.util.sched.Actor;
import io.zeebe.util.sched.channel.ActorConditions;
import io.zeebe.util.sched.future.ActorFuture;
import org.agrona.MutableDirectBuffer;
import org.slf4j.Logger;

/**
 * Consume the write buffer and append the blocks on the log storage.
 */
public class LogStorageAppender extends Actor
{
    public static final Logger LOG = Loggers.LOGSTREAMS_LOGGER;

    private final AtomicBoolean isFailed = new AtomicBoolean(false);

    private final BlockPeek blockPeek = new BlockPeek();

    private final String name;
    private final LogStorage logStorage;
    private final Subscription writeBufferSubscription;
    private final ActorConditions logStorageAppendConditions;

    private Runnable peekedBlockHandler = this::appendBlock;
    private int maxAppendBlockSize;


    public LogStorageAppender(String name,
        LogStorage logStorage,
        Subscription writeBufferSubscription,
        int maxBlockSize,
        ActorConditions logStorageAppendConditions)
    {
        this.name = name;
        this.logStorage = logStorage;
        this.writeBufferSubscription = writeBufferSubscription;
        this.maxAppendBlockSize = maxBlockSize;
        this.logStorageAppendConditions = logStorageAppendConditions;
    }

    @Override
    public String getName()
    {
        return name;
    }

    @Override
    protected void onActorStarting()
    {
        actor.consume(writeBufferSubscription, this::peekBlock);
    }

    private void peekBlock()
    {
        if (writeBufferSubscription.peekBlock(blockPeek, maxAppendBlockSize, true) > 0)
        {
            peekedBlockHandler.run();
        }
        else
        {
            actor.yield();
        }
    }

    private void appendBlock()
    {
        final ByteBuffer rawBuffer = blockPeek.getRawBuffer();
        final MutableDirectBuffer buffer = blockPeek.getBuffer();

        final long address = logStorage.append(rawBuffer);
        if (address >= 0)
        {
            blockPeek.markCompleted();
            logStorageAppendConditions.signalConsumers();
        }
        else
        {
            isFailed.set(true);

            final long positionOfFirstEventInBlock = LogEntryDescriptor.getPosition(buffer, 0);
            LOG.error("Failed to append log storage on position '{}'. Stop writing to log storage until recovered.", positionOfFirstEventInBlock);

            // recover log storage from failure - see zeebe-io/zeebe#500
            peekedBlockHandler = this::discardBlock;

            discardBlock();
        }
    }

    private void discardBlock()
    {
        blockPeek.markFailed();
        // continue with next block
        actor.yield();
    }

    public ActorFuture close()
    {
        return actor.close();
    }

    public boolean isFailed()
    {
        return isFailed.get();
    }

    public long getCurrentAppenderPosition()
    {
        return writeBufferSubscription.getPosition();
    }
}