io.bdeploy.bhive.cli.PoolTool Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of api Show documentation
Public API including dependencies, ready to be used for integrations and plugins.
The newest version!
package io.bdeploy.bhive.cli;

import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Set;

import io.bdeploy.bhive.BHive;
import io.bdeploy.bhive.BHivePoolOrganizer;
import io.bdeploy.bhive.cli.PoolTool.PoolConfig;
import io.bdeploy.bhive.objects.view.ElementView;
import io.bdeploy.bhive.op.FsckOperation;
import io.bdeploy.bhive.remote.jersey.BHiveRegistry;
import io.bdeploy.common.audit.NullAuditor;
import io.bdeploy.common.cfg.Configuration.EnvironmentFallback;
import io.bdeploy.common.cfg.Configuration.Help;
import io.bdeploy.common.cfg.Configuration.Validator;
import io.bdeploy.common.cfg.ExistingPathValidator;
import io.bdeploy.common.cfg.PathOwnershipValidator;
import io.bdeploy.common.cli.ToolBase.CliTool.CliName;
import io.bdeploy.common.cli.ToolBase.ConfiguredCliTool;
import io.bdeploy.common.cli.ToolCategory;
import io.bdeploy.common.cli.data.RenderableResult;
import io.bdeploy.common.util.PathHelper;
import io.bdeploy.jersey.actions.ActionService;

@Help("Configures pooling on a given BHive.")
@ToolCategory(BHiveCli.SERVER_TOOLS)
@CliName("pool")
public class PoolTool extends ConfiguredCliTool {

    public @interface PoolConfig {

        @Help("The target BHive to configure")
        @EnvironmentFallback("BHIVE")
        @Validator({ ExistingPathValidator.class, PathOwnershipValidator.class })
        String hive();

        @Help("Path to the pool directory to use. May be an existing pool or non-existant.")
        String pool();

        @Help(value = "Force resetting the pool directory. Attention: the new pool directory MUST contain all required objects from the previous pool.",
              arg = false)
        boolean force() default false;

        @Help(value = "If pooling is enabled on this BHive, disable it and copy all required objects from the pool to the local storage",
              arg = false)
        boolean unpool() default false;

        @Help("A list of BHives whose pools should be updated. ATTENTION: all BHives using a certain pool must be given, as unreferenced objects will be deleted from the pool.")
        String[] reorganize();

        @Help("The threshold of how many times an object must be equal in pooled hives before being moved to the pool.")
        int usageThreshold() default 2;
    }

    public PoolTool() {
        super(PoolConfig.class);
    }

    @Override
    protected RenderableResult run(PoolConfig config) {
        if (config.pool() != null) {
            helpAndFailIfMissing(config.hive(), "Missing --hive");
            Path root = Paths.get(config.hive());

            out().println("WARNING: setting a BHives pool requires restarting of any existing application");
            out().println("accessing this BHive, otherwise pooling settings will not be respected.");

            try (BHive hive = new BHive(root.toUri(), getAuditorFactory().apply(root), getActivityReporter())) {
                Path pool = Paths.get(config.pool());

                if (!PathHelper.exists(pool)) {
                    PathHelper.mkdirs(pool);
                }

                Path old = hive.getPoolPath();
                hive.enablePooling(pool, config.force());

                if (config.force() && old != null) {
                    out().println("Force was given and a pool was set already, forcing full consistency check with new pool.");

                    Set problems = hive.execute(new FsckOperation());

                    if (!problems.isEmpty()) {
                        out().println("Consistency check failed, cannot move to new pool, reverting to existing pool!");
                        hive.enablePooling(old, true);
                    } else {
                        out().println("Consistency check OK, moving to new pool.");
                    }
                }
            }
        } else if (config.unpool()) {
            helpAndFailIfMissing(config.hive(), "Missing --hive");
            Path root = Paths.get(config.hive());

            try (BHive hive = new BHive(root.toUri(), getAuditorFactory().apply(root), getActivityReporter())) {
                hive.disablePooling();
            }
        } else if (config.reorganize() != null && config.reorganize().length > 0) {
            if (config.reorganize().length < 2) {
                return createResultWithErrorMessage("At least two hives must be given to reorganize");
            }
            BHiveRegistry reg = new BHiveRegistry(getActivityReporter());
            for (String hivePath : config.reorganize()) {
                Path path = Paths.get(hivePath);
                reg.register(hivePath, new BHive(path.toUri(), getAuditorFactory().apply(path), getActivityReporter()));
            }

            BHivePoolOrganizer.reorganizeAll(reg, config.usageThreshold(), new ActionService(null, new NullAuditor()));
        } else {
            return createNoOp();
        }

        return createSuccess();
    }

}