Queuing...

Kai Reinhard

19.55.2018 85e946e076184ce6166cf07f66190ac1f3f59475

Queuing...

 borgbutler-core/src/main/java/de/micromata/borgbutler/BorgCommands.java

@@ -10,6 +10,7 @@
import de.micromata.borgbutler.utils.ReplaceUtils;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@@ -173,10 +174,14 @@
    }

    private static String execute(BorgCommand command) {
        return BorgExecutorQueue.getInstance().execute(command);
        Validate.notNull(command);
        Validate.notNull(command.repoConfig);
        return BorgExecutorQueue.getQueue(command.repoConfig).execute(command);
    }

    private static void execute(OutputStream outputStream, BorgCommand command) {
        BorgExecutorQueue.getInstance().execute(outputStream, command);
        Validate.notNull(command);
        Validate.notNull(command.repoConfig);
        BorgExecutorQueue.getQueue(command.repoConfig).execute(outputStream, command);
    }
}

 borgbutler-core/src/main/java/de/micromata/borgbutler/BorgExecutorQueue.java

@@ -13,23 +13,41 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.naming.Context;
import java.io.IOException;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * A queue is important because Borg doesn't support parallel calls for one repository.
 * For each repository one single queue is allocated.
 */
public class BorgExecutorQueue {
    private Logger log = LoggerFactory.getLogger(BorgExecutorQueue.class);
    private static BorgExecutorQueue instance = new BorgExecutorQueue();
    // key is the repo name.
    private static Map<String, BorgExecutorQueue> queueMap = new HashMap<>();

    public static BorgExecutorQueue getInstance() {
        return instance;
    public static BorgExecutorQueue getQueue(BorgRepoConfig config) {
        synchronized (queueMap) {
            BorgExecutorQueue queue = queueMap.get(config.getRepo());
            if (queue == null) {
                queue = new BorgExecutorQueue();
                queueMap.put(config.getRepo(), queue);
            }
            return queue;
        }
    }

    private ConcurrentLinkedQueue<BorgCommand> commandQueue = new ConcurrentLinkedQueue<>();

    public String execute(BorgCommand command) {
        synchronized (this) {
            return _exceute(command);
        }
    }

    private String _exceute(BorgCommand command) {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        execute(outputStream, command);
        String json = outputStream.toString(Definitions.STD_CHARSET);
@@ -37,6 +55,12 @@
    }

    public void execute(OutputStream outputStream, BorgCommand command) {
        synchronized (this) {
            _execute(outputStream, command);
        }
    }

    private void _execute(OutputStream outputStream, BorgCommand command) {
        CommandLine cmdLine = new CommandLine(ConfigurationHandler.getConfiguration().getBorgCommand());
        cmdLine.addArgument(command.command);
        if (command.params != null) {