src.com.android.server.backup.encryption.chunking.SingleStreamDiffScriptWriter Maven / Gradle / Ivy

Go to download
/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * 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 com.android.server.backup.encryption.chunking;

import android.annotation.Nullable;

import com.android.internal.util.Preconditions;

import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.util.Locale;

/**
 * A {@link DiffScriptWriter} that writes an entire diff script to a single {@link OutputStream}.
 */
public class SingleStreamDiffScriptWriter implements DiffScriptWriter {
    static final byte LINE_SEPARATOR = 0xA;
    private static final Charset UTF_8 = Charset.forName("UTF-8");

    private final int mMaxNewByteChunkSize;
    private final OutputStream mOutputStream;
    private final byte[] mByteBuffer;
    private int mBufferSize = 0;
    // Each chunk could be written immediately to the output stream. However,
    // it is possible that chunks may overlap. We therefore cache the most recent
    // reusable chunk and try to merge it with future chunks.
    private ByteRange mReusableChunk;

    public SingleStreamDiffScriptWriter(OutputStream outputStream, int maxNewByteChunkSize) {
        mOutputStream = outputStream;
        mMaxNewByteChunkSize = maxNewByteChunkSize;
        mByteBuffer = new byte[maxNewByteChunkSize];
    }

    @Override
    public void writeByte(byte b) throws IOException {
        if (mReusableChunk != null) {
            writeReusableChunk();
        }
        mByteBuffer[mBufferSize++] = b;
        if (mBufferSize == mMaxNewByteChunkSize) {
            writeByteBuffer();
        }
    }

    @Override
    public void writeChunk(long chunkStart, int chunkLength) throws IOException {
        Preconditions.checkArgument(chunkStart >= 0);
        Preconditions.checkArgument(chunkLength > 0);
        if (mBufferSize != 0) {
            writeByteBuffer();
        }

        if (mReusableChunk != null && mReusableChunk.getEnd() + 1 == chunkStart) {
            // The new chunk overlaps the old, so combine them into a single byte range.
            mReusableChunk = mReusableChunk.extend(chunkLength);
        } else {
            writeReusableChunk();
            mReusableChunk = new ByteRange(chunkStart, chunkStart + chunkLength - 1);
        }
    }

    @Override
    public void flush() throws IOException {
        Preconditions.checkState(!(mBufferSize != 0 && mReusableChunk != null));
        if (mBufferSize != 0) {
            writeByteBuffer();
        }
        if (mReusableChunk != null) {
            writeReusableChunk();
        }
        mOutputStream.flush();
    }

    private void writeByteBuffer() throws IOException {
        mOutputStream.write(Integer.toString(mBufferSize).getBytes(UTF_8));
        mOutputStream.write(LINE_SEPARATOR);
        mOutputStream.write(mByteBuffer, 0, mBufferSize);
        mOutputStream.write(LINE_SEPARATOR);
        mBufferSize = 0;
    }

    private void writeReusableChunk() throws IOException {
        if (mReusableChunk != null) {
            mOutputStream.write(
                    String.format(
                                    Locale.US,
                                    "%d-%d",
                                    mReusableChunk.getStart(),
                                    mReusableChunk.getEnd())
                            .getBytes(UTF_8));
            mOutputStream.write(LINE_SEPARATOR);
            mReusableChunk = null;
        }
    }

    /** A factory that creates {@link SingleStreamDiffScriptWriter}s. */
    public static class Factory implements DiffScriptWriter.Factory {
        private final int mMaxNewByteChunkSize;
        private final OutputStreamWrapper mOutputStreamWrapper;

        public Factory(int maxNewByteChunkSize, @Nullable OutputStreamWrapper outputStreamWrapper) {
            mMaxNewByteChunkSize = maxNewByteChunkSize;
            mOutputStreamWrapper = outputStreamWrapper;
        }

        @Override
        public SingleStreamDiffScriptWriter create(OutputStream outputStream) {
            if (mOutputStreamWrapper != null) {
                outputStream = mOutputStreamWrapper.wrap(outputStream);
            }
            return new SingleStreamDiffScriptWriter(outputStream, mMaxNewByteChunkSize);
        }
    }
}