apps/yms/app/src/main/java/org/onosproject/yms/app/ydt/YangRequestWorkBench.java

/*
 * Copyright 2016-present Open Networking Foundation
 *
 * 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.onosproject.yms.app.ydt;

import com.google.common.collect.ImmutableMap;
import org.onosproject.yangutils.datamodel.YangAugment;
import org.onosproject.yangutils.datamodel.YangLeaf;
import org.onosproject.yangutils.datamodel.YangList;
import org.onosproject.yangutils.datamodel.YangSchemaNode;
import org.onosproject.yangutils.datamodel.YangSchemaNodeContextInfo;
import org.onosproject.yangutils.datamodel.YangSchemaNodeIdentifier;
import org.onosproject.yms.app.ydt.exceptions.YdtException;
import org.onosproject.yms.app.ysr.YangSchemaRegistry;
import org.onosproject.yms.ydt.YdtContext;
import org.onosproject.yms.ydt.YdtContextOperationType;
import org.onosproject.yms.ydt.YdtType;
import org.onosproject.yms.ydt.YmsOperationType;

import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static org.onosproject.yms.app.ydt.AppNodeFactory.getAppContext;
import static org.onosproject.yms.app.ydt.RequestedCallType.LEAF;
import static org.onosproject.yms.app.ydt.RequestedCallType.NON_LEAF;
import static org.onosproject.yms.app.ydt.RequestedCardinality.MULTI_INSTANCE;
import static org.onosproject.yms.app.ydt.RequestedCardinality.MULTI_INSTANCE_LEAF;
import static org.onosproject.yms.app.ydt.RequestedCardinality.SINGLE_INSTANCE;
import static org.onosproject.yms.app.ydt.RequestedCardinality.UNKNOWN;
import static org.onosproject.yms.app.ydt.YdtConstants.errorMsg;
import static org.onosproject.yms.app.ydt.YdtNodeFactory.getNode;
import static org.onosproject.yms.app.ydt.YdtNodeFactory.getYangSchemaNodeTypeSpecificContext;
import static org.onosproject.yms.app.ydt.YdtUtils.checkElementCount;
import static org.onosproject.yms.app.ydt.YdtUtils.freeRestResources;
import static org.onosproject.yms.app.ydt.YdtUtils.getAppOpTypeFromYdtOpType;
import static org.onosproject.yms.app.ydt.YdtUtils.getAugmentingSchemaNode;
import static org.onosproject.yms.app.ydt.YdtUtils.getNodeIdentifier;
import static org.onosproject.yms.app.ydt.YdtUtils.getValidOpType;
import static org.onosproject.yms.ydt.YdtContextOperationType.DELETE;
import static org.onosproject.yms.ydt.YdtContextOperationType.REMOVE;
import static org.onosproject.yms.ydt.YdtType.MULTI_INSTANCE_LEAF_VALUE_NODE;
import static org.onosproject.yms.ydt.YdtType.MULTI_INSTANCE_NODE;

/**
 * Represents YANG request work bench which contains all parameters for
 * request handling and methods to build and obtain YANG data tree
 * which is data (sub)instance representation, abstract of protocol.
 */
public class YangRequestWorkBench implements YdtExtendedBuilder {

    // Ydt formatted error string
    private static final String FMT_NOT_EXIST =
            "Application with name \"%s\" doesn't exist.";

    // Ydt error strings.
    private static final String E_USE_ADD_LEAF =
            "Requested Node should be created using addLeaf interface.";

    private static final String E_INVOKE_PARENT =
            "Can't invoke get parent at logical root node.";

    /*
     * Reference for the current context node in YANG data tree.
     */
    private YdtNode curNode;

    /*
     * Reference for the logical root node in YANG data tree.
     */
    private YdtNode rootNode;

    /*
     * Reference for the current context in ydt application tree.
     */
    private YdtAppContext appCurNode;

    /*
     * Reference for the logical root node context in ydt application tree.
     */
    private YdtAppContext appRootNode;

    /**
     * Root Node Tag attribute in YANG data tree, kept to maintain the root
     * tag attributes in YDT.
     * <p>
     * First key param of map represent tagName  name of tag attribute.
     * Second param of map represent tagValue value of tag attribute
     */
    private Map<String, String> rootTagAttributeMap;

    /*
     * YANG schema registry reference.
     */
    private YangSchemaRegistry registry = null;

    /*
     * YMS operation type.
     */
    private final YmsOperationType ymsOperationType;

    /*
     * YDT default operation type.
     */
    private YdtContextOperationType ydtDefaultOpType;

    /*
     * Flag to identify data validation need to be done by YDT or not.
     */
    private boolean validate = false;
    // TODO validate need to be handle later with interaction type basis in
    // future when it will be supported

    /*
     * Reference for application tree node set.
     * This set contains the method name's generated for an augmented
     * target node to avoid the duplicate entries in YDT application tree for
     * multiple augmented nodes under a single XPATH.
     */
    private Set<String> augGenMethodSet;

    /**
     * Creates an instance of YANG request work bench which is use to initialize
     * logical rootNode and and schema registry.
     *
     * @param name       name of logical container of a protocol
     *                   which is a holder of the complete tree
     * @param namespace  namespace of logical container
     * @param opType     type of operation done by using YANG
     *                   interface
     * @param reg        Yang schema registry
     * @param isValidate Flag to identify data validation need to be
     *                   done by YDT or not
     */
    public YangRequestWorkBench(String name, String namespace,
                                YmsOperationType opType,
                                YangSchemaRegistry reg,
                                boolean isValidate) {

        setRootNode(new YdtLogicalNode(name, namespace));
        registry = reg;
        ymsOperationType = opType;
        validate = isValidate;

        setAppRootNode(getAppContext(true));
    }

    /**
     * Sets the logical root node for ydt.
     *
     * @param node ydt logical root node
     */
    private void setRootNode(YdtNode node) {
        rootNode = node;
        curNode = node;
    }

    /**
     * Sets the logical root node for ydt application tree.
     *
     * @param node ydt application context logical root node
     */
    private void setAppRootNode(YdtAppContext node) {
        appRootNode = node;
        appCurNode = node;
    }

    /**
     * Returns the YANG schema registry of Ydt.
     * This method will be used by ytb.
     *
     * @return YANG schema registry
     */
    public YangSchemaRegistry getYangSchemaRegistry() {
        return registry;
    }

    /**
     * Returns the ydt app context tree logical root node.
     * This method will be used by yab and ytb.
     *
     * @return YdtAppContext app tree logical root node
     */
    public YdtAppContext getAppRootNode() {
        return appRootNode;
    }

    /**
     * Returns the ydt module node with requested node identifier.
     *
     * @param id module/application node identifier
     * @return YANG data tree node
     * @throws YdtException when user requested node schema doesn't exist or
     *                      requested node is already part of the tree
     */
    private YdtNode moduleHandler(YangSchemaNodeIdentifier id)
            throws YdtException {

        YangSchemaNode node =
                registry.getYangSchemaNodeUsingSchemaName(id.getName());

        String namespace = id.getNameSpace().getModuleNamespace();

        /*
         * Checking received schema node is having same namespace as
         * requested by user or not.
         */
        if (node == null || namespace != null &&
                !namespace.equals(node.getYangSchemaNodeIdentifier()
                                          .getNameSpace()
                                          .getModuleNamespace())) {
            throw new YdtException(errorMsg(FMT_NOT_EXIST, id.getName()));
        }

        /*
         * If yms operation is for query then no validation need to be
         * performed.
         */
        if (ymsOperationType != YmsOperationType.QUERY_REQUEST) {
            // Checking whether module node is already exits in YDT or not.
            try {
                curNode.getCollidingChild(id);
            } catch (YdtException e) {
                throw new YdtException(e.getLocalizedMessage());
            }
        }

        YdtNode newNode = new YdtSingleInstanceNode(node);
        newNode.setYangSchemaNode(node);
        return newNode;
    }

    @Override
    public void setRootTagAttributeMap(Map<String, String> attributeTag) {
        rootTagAttributeMap = attributeTag;
    }

    @Override
    public Map<String, String> getRootTagAttributeMap() {
        if (rootTagAttributeMap != null) {
            return ImmutableMap.copyOf(rootTagAttributeMap);
        }
        return null;
    }

    @Override
    public void addChild(String name, String namespace)
            throws IllegalArgumentException {
        addChild(name, namespace, UNKNOWN, null, NON_LEAF);
    }

    @Override
    public void addChild(String name, String namespace, YdtType ydtType)
            throws IllegalArgumentException {
        addChild(name, namespace, ydtType, null);
    }

    @Override
    public void addChild(String name, String namespace,
                         YdtContextOperationType opType)
            throws IllegalArgumentException {
        addChild(name, namespace, UNKNOWN, opType, NON_LEAF);
    }

    @Override
    public void addChild(String name, String namespace, YdtType ydtType,
                         YdtContextOperationType opType)
            throws IllegalArgumentException {
        RequestedCardinality cardinality;
        switch (ydtType) {
            case MULTI_INSTANCE_NODE:
                cardinality = MULTI_INSTANCE;
                break;
            case SINGLE_INSTANCE_NODE:
                cardinality = SINGLE_INSTANCE;
                break;
            default:
                throw new IllegalArgumentException(E_USE_ADD_LEAF);
        }
        addChild(name, namespace, cardinality, opType, NON_LEAF);
    }

    /**
     * Adds a last child to YANG data tree; this method is to be used by all
     * protocols internally which are aware or unaware of the nature
     * (single/multiple) of node.
     *
     * @param name        name of child to be added
     * @param namespace   namespace of child to be added
     * @param cardinality type of YANG data tree node operation
     * @param opType      type of requested operation over a node
     * @param callType    to identify the whether its a leaf or other node
     * @throws IllegalArgumentException when method has been passed an illegal
     *                                  or inappropriate argument.
     */
    private void addChild(String name, String namespace,
                          RequestedCardinality cardinality,
                          YdtContextOperationType opType,
                          RequestedCallType callType)
            throws IllegalArgumentException {

        YdtNode newNode;
        boolean contextSwitch = false;
        YangSchemaNode augmentingSchema = null;
        YangSchemaNodeIdentifier id = getNodeIdentifier(name, namespace);
        if (name == null) {
            if (!curNode.equals(rootNode)) {
                throw new YdtException("Name is null for node other than module");
            }

            /*
             * Since XML will not have module name, id.name will be null. In
             * that case get schema node by using namespace. In NBI flow,
             * name will never be null.
             */
            YangSchemaNode node = registry
                    .getSchemaWrtNameSpace(id.getNameSpace().getModuleNamespace());
            id.setName(node.getName());
        }

        try {
            // Module/sub-module node handler.
            if (curNode.equals(rootNode)) {
                newNode = moduleHandler(id);
            } else {

                YangSchemaNode schemaNode;
                YangSchemaNodeContextInfo contextInfo;

                // If namespace given by user null, then take namespace from parent.
                if (namespace == null) {
                    id.setNameSpace(curNode.getYangSchemaNode().getNameSpace());
                }

                /*
                 * Get the already exiting YDT node in YDT tree with same
                 * nodeIdentifier
                 */
                newNode = curNode.getCollidingChild(id);

                /*
                 * If colliding child doesn't exist ,
                 * then query yang data model for schema of given node.
                 */
                if (newNode == null) {
                    /*
                     * Get Yang Schema node context info which is having
                     * YangSchemaNode and ContextSwitchedNode.
                     */
                    contextInfo = curNode.getSchemaNodeContextInfo(id);

                    if (contextInfo.getContextSwitchedNode() != null) {
                        augmentingSchema = getAugmentingSchemaNode(
                                id, contextInfo);
                        if (augmentingSchema != null) {
                            /*
                             * As two tree(YDT and YDT Application Tree) are getting
                             * prepared in parallel, So  setting context switch
                             * flag it will help ydt to keep the track whether
                             * ydtApp tree also need to be traversed back to parent
                             * or not with YDT tree traverse to parent call.
                             */
                            contextSwitch = true;
                        }
                    }
                    schemaNode = contextInfo.getSchemaNode();
                } else {
                    /*
                     * If colliding child exist , then it will be leaf-list or list.
                     * If its leaf-list then return and add new requested
                     * value/valueSet in same node else take yang data model
                     * information from colliding child.
                     */
                    if (newNode.getYdtType() == MULTI_INSTANCE_LEAF_VALUE_NODE) {
                        curNode = newNode;
                        return;
                    }
                    schemaNode = newNode.getYangSchemaNode();
                }

                /*
                 * For yms query request node specific validation are not
                 * required as rest-conf can call addChild api for leaf/leaf-list
                 * node addition also in ydt.
                 */
                if (ymsOperationType == YmsOperationType.QUERY_REQUEST) {
                    newNode = getYangSchemaNodeTypeSpecificContext(schemaNode);
                } else {
                    newNode = getNode(schemaNode, cardinality, callType);
                }
            }

            opType = getValidOpType(opType, ydtDefaultOpType, newNode, curNode);

            newNode.setYdtContextOperationType(opType);

            curNode.addChild(newNode, true);
        } catch (YdtException e) {
            freeRestResources(rootNode);
            throw new IllegalArgumentException(e.getLocalizedMessage());
        }

        // Update parent ydt node map.
        curNode.updateYdtMap(newNode);

        processAppTree(opType, newNode, augmentingSchema, contextSwitch);

        curNode = newNode;
    }

    /**
     * Processes application tree on the bases of requested ydt node.
     *
     * @param opType           user requested operation type
     * @param childNode        requested ydt node
     * @param augmentingSchema schema of last augmenting node
     * @param contextSwitch    true, for module node call; false for modules
     *                         sub-node calls
     */
    private void processAppTree(
            YdtContextOperationType opType, YdtNode childNode,
            YangSchemaNode augmentingSchema, boolean contextSwitch) {

        if (curNode == rootNode) {
            augGenMethodSet = new HashSet<>();
        }

        if (opType == null) {
            opType = curNode.getYdtContextOperationType();
        } else {
            // Updating operation type for parent nodes
            appCurNode.updateAppOperationType(opType);
        }

        /*
         * This is to avoid multiple entries of single augmented target.
         */
        if (augmentingSchema != null) {
            if (!augGenMethodSet.add(((YangAugment) augmentingSchema)
                                             .getSetterMethodName())) {
                return;
            }
        }

        /*
         * Create entry of module node in ydt app tree.
         * Or if context switch happened then also add entry for same
         * augmented ydt node in the ydt application tree.
         */
        if (curNode.equals(rootNode) || contextSwitch) {
            addChildInAppTree(childNode, augmentingSchema, opType,
                              contextSwitch);

            // Setting app tree node operation.
            appCurNode.setOperationType(getAppOpTypeFromYdtOpType(opType));
        }

        // Updating the delete operation list in app tree.
        if (opType == DELETE || opType == REMOVE) {
            appCurNode.addDeleteNode(childNode);
        }
    }


    /**
     * Adds a last child to YANG app data tree.this method is to be used
     * internally by other ydt interfaces.
     *
     * @param childNode       node to be added in tree
     * @param schemaNode      last augmenting module node
     * @param childOpType     operation type of node
     * @param isContextSwitch true, for module node call; false for modules
     *                        sub-node calls
     */
    private void addChildInAppTree(YdtNode childNode,
                                   YangSchemaNode schemaNode,
                                   YdtContextOperationType childOpType,
                                   boolean isContextSwitch) {

        YdtAppNodeOperationType opType;

        DefaultYdtAppContext appContext = getAppContext(isContextSwitch);

        // Add context switched child in ydt App tree.
        appCurNode.addChild(appContext);

        appCurNode = appContext;

        opType = getAppOpTypeFromYdtOpType(childOpType);

        appCurNode.setAppData(childNode, schemaNode);

        appCurNode.setOperationType(opType);

        childNode.setAppContextSwitch();
    }

    @Override
    public void addLeaf(String name, String namespace, String value)
            throws IllegalArgumentException {
        addLeaf(name, namespace, value, null, UNKNOWN);
    }

    @Override
    public void addLeaf(String name, String namespace, Set<String> valueSet)
            throws IllegalArgumentException {
        addLeaf(name, namespace, null, valueSet, MULTI_INSTANCE_LEAF);
    }

    @Override
    public void addNode(String name, String namespace)
            throws IllegalArgumentException {
        addChild(name, namespace, RequestedCardinality.UNKNOWN,
                null, RequestedCallType.EMPTY_CONTAINER);
    }


    /**
     * Adds a last leaf with list of values/single value to YANG data tree.
     * This method is used by all protocols which knows the nature
     * (single/multiple) or not.
     * Value of leaf can be null which indicates selection node in get
     * operation.
     *
     * @param name        name of child to be added
     * @param namespace   namespace of child to be added, if it's
     *                    null, parent's
     *                    namespace will be applied to child
     * @param value       value of the child
     * @param valueSet    list of value of the child
     * @param cardinality type of YANG data tree node operation
     * @throws IllegalArgumentException when method has been passed an illegal
     *                                  or inappropriate argument.
     */
    private void addLeaf(String name, String namespace, String value,
                         Set<String> valueSet,
                         RequestedCardinality cardinality)
            throws IllegalArgumentException {
        try {
            addChild(name, namespace, cardinality, null, LEAF);

            // After successful addition of child node updating the values in same.
            if (value != null) {
                curNode.addValue(value);
            } else if (valueSet != null) {
                curNode.addValueSet(valueSet);
            }
        } catch (YdtException e) {
            freeRestResources(rootNode);
            throw new IllegalArgumentException(e.getLocalizedMessage());
        }
    }

    @Override
    public void traverseToParent() throws IllegalStateException {
        // If traverse back to parent for logical root node comes
        if (curNode.equals(rootNode)) {
            freeRestResources(rootNode);
            throw new IllegalStateException(E_INVOKE_PARENT);
        }

        try {

            // If node is of multiInstanceNode type then check key uniqueness.
            if (curNode.getYdtType() == MULTI_INSTANCE_NODE) {
                List<YdtContext> keyList = ((YdtMultiInstanceNode) curNode).getKeyNodeList();
                if (keyList == null || keyList.isEmpty()) {
                    curNode.createKeyNodeList();
                }
            }

            /*
             * Check application switch for curNode if set,
             * then traverseToParent in YDT application tree.
             */
            if (curNode.getParent().equals(rootNode) ||
                    curNode.getAppContextSwitch()) {
                traverseToAppTreeParent();
            }

            /*
             * Validate all multi Instance inside current context,
             * This is not valid for leaf and leaf-list node.
             */
            if (curNode instanceof YdtMultiInstanceNode ||
                    curNode instanceof YdtSingleInstanceNode) {
                curNode.validateMultiInstanceNode();
            }

            curNode = curNode.getParent();
        } catch (YdtException e) {
            freeRestResources(rootNode);
            throw new IllegalStateException(e.getLocalizedMessage());
        }
    }

    /**
     * Traverses up in YANG application tree to the parent node,
     * This will be used when Ydt current context switch flag is set.
     */
    private void traverseToAppTreeParent() {
        appCurNode = appCurNode.getParent();
    }

    @Override
    public YdtExtendedContext getCurNode() {
        return curNode;
    }

    @Override
    public void setDefaultEditOperationType(
            YdtContextOperationType opType) {
        ydtDefaultOpType = opType;
    }

    @Override
    public YdtExtendedContext getRootNode() {
        return rootNode;
    }

    @Override
    public YmsOperationType getYmsOperationType() {
        return ymsOperationType;
    }

    @Override
    public void addMultiInstanceChild(String name, String namespace,
                                      List<String> keysValueList,
                                      YdtContextOperationType opType)
            throws IllegalArgumentException {

        addChild(name, namespace, UNKNOWN, opType,
                 RequestedCallType.MULTI_INSTANCE);
        int inputCount = keysValueList.size();

        try {
            if (curNode.getYdtType() == MULTI_INSTANCE_LEAF_VALUE_NODE) {

            /*
             * Calculating the current leaf-list node array size by adding
             * existing elements count and new supplied elements by user for
             * the same.
             */
                // TODO instance count for leaf list need to be handled.
//            if (curNode.getValueSet().size() + inputCount > expectedCount) {
//                curNode.errorHandler(
//                        errorMsg(FMT_MANY_INS, name, expectedCount), rootNode);
//            }

            /*
             * After successful addition of child node updating
             * the values in same.
             */
                for (String value : keysValueList) {
                    curNode.addValue(value);
                }
            } else if (curNode.getYdtType() == MULTI_INSTANCE_NODE) {

                YangList yangListHolder = (YangList) curNode.getYangSchemaNode();
                List<String> schemaKeyList = yangListHolder.getKeyList();
                int expectedCount = schemaKeyList.size();
                checkElementCount(name, expectedCount, inputCount);

                //After validation adding the key nodes under the list node.
                Iterator<String> sklIter = schemaKeyList.iterator();
                Iterator<String> kvlIter = keysValueList.iterator();
                String keyEleName;

                while (kvlIter.hasNext()) {
                    String value = kvlIter.next();
                    keyEleName = sklIter.next();
                    addLeaf(keyEleName, namespace, value);
                    if (kvlIter.hasNext()) {
                        traverseToParentWithoutValidation();
                    }
                }

                curNode = curNode.getParent();
                curNode.createKeyNodeList();
            }
        } catch (YdtException e) {
            freeRestResources(rootNode);
            throw new IllegalArgumentException(e.getLocalizedMessage());
        }
    }

    /**
     * Adds a last child to YANG data tree, this method is to be used by
     * YANG object builder sub-calls internally.
     *
     * @param opType type of requested operation over a node
     * @return returns added ydt node in YDT tree
     */
    private YdtNode addExtendedChildNode(YdtContextOperationType opType,
                                         YangSchemaNode schemaNode) {

        YdtNode childNode = getYangSchemaNodeTypeSpecificContext(schemaNode);

        childNode.setYangSchemaNode(schemaNode);

        childNode.setYdtContextOperationType(opType);

        curNode.addChild(childNode, true);

        curNode = childNode;

        return childNode;
    }

    @Override
    public YdtExtendedContext addChild(YdtContextOperationType opType,
                                       YangSchemaNode schemaNode) {
        return addExtendedChildNode(opType, schemaNode);
    }

    @Override
    public YdtExtendedContext addLeafList(Set<String> valueSet,
                                          YangSchemaNode schemaNode) {
        YdtNode childNode = addExtendedChildNode(null, schemaNode);

        /*
         * After successful addition of child node updating the values in
         * valueSet.
         */
        childNode.addValueSetWithoutValidation(valueSet);
        return childNode;
    }

    @Override
    public YdtExtendedContext addLeaf(String value, YangSchemaNode schemaNode) {

        YdtNode childNode = addExtendedChildNode(null, schemaNode);

        // After successful addition of child node updating the values in same.
        childNode.addValueWithoutValidation(value, ((YangLeaf) schemaNode)
                .isKeyLeaf());
        return childNode;
    }

    @Override
    public void traverseToParentWithoutValidation()
            throws IllegalStateException {
        // If traverse back to parent for logical root node comes.
        if (curNode.equals(rootNode)) {
            freeRestResources(rootNode);
            throw new IllegalStateException(E_INVOKE_PARENT);
        }
        curNode = curNode.getParent();
    }

    /**
     * Returns the method name's set for an augmented target node in an
     * application tree.
     *
     * @return augGenMethodSet set of method name's
     */
    public Set<String> getAugGenMethodSet() {
        return augGenMethodSet;
    }

    /**
     * Sets the method name's set for an augmented target node in an
     * application tree.
     *
     * @param augGenMethodSet set of method name's
     */
    public void setAugGenMethodSet(Set<String> augGenMethodSet) {
        this.augGenMethodSet = augGenMethodSet;
    }
}