org.rundeck.storage.conf.TreeBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rundeck-storage-conf Show documentation
Rundeck
There is a newer version: 5.8.0-20241205
/*
 * Copyright 2016 SimplifyOps, Inc. (http://simplifyops.com)
 *
 * 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 org.rundeck.storage.conf;

import org.rundeck.storage.impl.EmptyTree;
import org.rundeck.storage.api.*;

import java.util.ArrayList;
import java.util.List;

/**
 * Builder for Resource Trees.  Allows extending a base tree with other trees at sub paths.  Content converters
 * and listeners can be
 * added selectively to sub paths, or based on analyzing the content.
 */
public class TreeBuilder {
    Tree base;
    List> treeStack;

    private TreeBuilder() {
        treeStack = new ArrayList>();
    }

    /**
     * Build a new tree with an empty base
     *
     * @param  content type
     *
     * @return builder
     */
    public static  TreeBuilder builder() {
        return new TreeBuilder().base(new EmptyTree());
    }

    /**
     * Build a new tree with given base
     *
     * @param base base tree
     * @param   content type
     *
     * @return builder
     */
    public static  TreeBuilder builder(Tree base) {
        return new TreeBuilder().base(base);
    }

    /**
     * Return a new tree which accesses the base tree at the given subpath, as a root tree.
     *
     * @param base base tree
     * @param   content type
     * @param subpath path
     *
     * @return root view of the subpath
     */
    public static  Tree subPathTree(Tree base, Path subpath) {
        return new PrefixPathTree(base, subpath);
    }

    /**
     * Set the base tree to be extended
     *
     * @param base base tree
     *
     * @return builder
     */
    public TreeBuilder base(Tree base) {
        this.base = base;
        return this;
    }

    /**
     * Add a tree responsible for a subpath of the base tree.
     *
     * @param path     sub path to handle
     * @param subtree  tree to delegate to for the path
     * @param fullPath if true, send resources to the subtree with the original full path, otherwise store with a path
     *                 relative to the path
     *
     * @return builder
     */
    public TreeBuilder subTree(Path path, Tree subtree, boolean fullPath) {
        treeStack.add(new SubPathTree(subtree, path, fullPath));
        return this;
    }

    /**
     * Convert data content for all resources below the given path
     *
     * @param converter content converter
     * @param path      sub path to convert data
     *
     * @return builder
     */
    public TreeBuilder convert(ContentConverter converter, Path path) {
        return convert(converter, PathUtil.subpathSelector(path));
    }

    /**
     * Convert data content for all resource paths matched by the path selector
     *
     * @param converter content converter
     * @param selector  path selection
     *
     * @return builder
     */
    public TreeBuilder convert(ContentConverter converter, PathSelector selector) {
        return TreeBuilder.builder(new ConverterTree(build(), converter, selector));
    }

    /**
     * Convert data content for all resources matching the selector
     *
     * @param converter content converter
     * @param selector  resource selector
     *
     * @return builder
     */
    public TreeBuilder convert(ContentConverter converter, ResourceSelector selector) {
        return TreeBuilder.builder(new ConverterTree(build(), converter, selector));
    }

    /**
     * Convert data content for all resources matching the resource selector and within the sub path
     *
     * @param converter        content converter
     * @param subpath          sub path
     * @param resourceSelector resource selector
     *
     * @return builder
     */
    public TreeBuilder convert(ContentConverter converter, Path subpath,
            ResourceSelector resourceSelector) {
        return convert(converter, PathUtil.subpathSelector(subpath), resourceSelector);
    }

    /**
     * Convert data content for all resources matching the resource selector and the path selector
     *
     * @param converter        content converter
     * @param pathSelector     path selector
     * @param resourceSelector resource selector
     *
     * @return builder
     */
    public TreeBuilder convert(ContentConverter converter, PathSelector pathSelector,
            ResourceSelector resourceSelector) {
        return TreeBuilder.builder(new ConverterTree(build(), converter, pathSelector, resourceSelector));
    }

    /**
     * Convert all content in the tree
     *
     * @param converter converter
     *
     * @return builder
     */
    public TreeBuilder convert(ContentConverter converter) {
        return TreeBuilder.builder(new ConverterTree(build(), converter, PathUtil.allpathSelector()));
    }

    /**
     * Listen to events on all paths of the tree
     *
     * @param listener listener
     *
     * @return builder
     */
    public TreeBuilder listen(Listener listener) {
        return listen(listener, PathUtil.allpathSelector());
    }

    /**
     * Listen to events on selective paths of the tree
     *
     * @param listener listener
     * @param pathSelector path selector
     * @return builder
     */
    public TreeBuilder listen(Listener listener, PathSelector pathSelector) {
        return TreeBuilder.builder(new ListenerTree(build(), listener, pathSelector));
    }
    /**
     * Listen to events on selective paths of the tree
     *
     * @param listener listener
     * @param subpath sub path
     * @return builder
     */
    public TreeBuilder listen(Listener listener, Path subpath) {
        return TreeBuilder.builder(new ListenerTree(build(), listener, PathUtil.subpathSelector(subpath)));
    }

    /**
     * Listen to events on selective resources of the tree
     *
     * @param listener listener
     * @param resourceSelector resource selector
     * @return builder
     */
    private TreeBuilder listen(Listener listener, ResourceSelector resourceSelector) {
        return TreeBuilder.builder(new ListenerTree(build(), listener, resourceSelector));
    }
    /**
     * Listen to events on selective resources of the tree
     *
     * @param listener listener
     * @param resourceSelector resource selector
     * @return builder
     */
    private TreeBuilder listen(Listener listener, String resourceSelector) {
        return TreeBuilder.builder(new ListenerTree(build(), listener,
                PathUtil.resourceSelector(resourceSelector)));
    }

    /**
     * Listen to events on selective resources and paths of the tree
     *
     * @param listener         listener
     * @param pathSelector     path selector
     * @param resourceSelector resource selector
     *
     * @return builder
     */
    private TreeBuilder listen(Listener listener, PathSelector pathSelector,
            ResourceSelector resourceSelector) {
        return TreeBuilder.builder(new ListenerTree(build(), listener,
                pathSelector, resourceSelector));
    }

    /**
     * Build the tree
     *
     * @return the tree
     */
    public Tree build() {
        Tree result = base;
        if (null == base && treeStack.size() == 1) {
            result = treeStack.get(0);
        } else if (treeStack.size() > 0) {
            result = new TreeStack(treeStack, base);
        }else if(null==base) {
            throw new IllegalArgumentException("base tree was not set");
        }

        return result;
    }
}