/*
* Copyright 2016-present Open Networking Laboratory
*
* 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.ysr;
import org.onosproject.yangutils.datamodel.YangInclude;
import org.onosproject.yangutils.datamodel.YangModule;
import org.onosproject.yangutils.datamodel.YangNode;
import org.onosproject.yangutils.datamodel.YangSchemaNode;
import org.onosproject.yangutils.datamodel.YangSubModule;
import org.onosproject.yangutils.datamodel.exceptions.DataModelException;
import org.onosproject.yms.ysr.YangModuleIdentifier;
import org.onosproject.yms.ysr.YangModuleInformation;
import org.onosproject.yms.ysr.YangModuleLibrary;
import org.slf4j.Logger;
import java.io.File;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.regex.Pattern;
import static java.util.Collections.sort;
import static org.apache.commons.io.FileUtils.deleteDirectory;
import static org.onosproject.yangutils.datamodel.utils.DataModelUtils.deSerializeDataModel;
import static org.onosproject.yangutils.utils.UtilConstants.EVENT_STRING;
import static org.onosproject.yangutils.utils.UtilConstants.HYPHEN;
import static org.onosproject.yangutils.utils.UtilConstants.OP_PARAM;
import static org.onosproject.yangutils.utils.UtilConstants.PERIOD;
import static org.onosproject.yangutils.utils.UtilConstants.SERVICE;
import static org.onosproject.yangutils.utils.UtilConstants.SLASH;
import static org.onosproject.yangutils.utils.io.impl.YangIoUtils.getCapitalCase;
import static org.slf4j.LoggerFactory.getLogger;
/**
* Representation of default YANG schema registry. Yang schema registry
* provides interface to an application to register its YANG schema
* with YMS. It provides YANG schema nodes to YDT, YNB and YSB.
*/
public class MockYangSchemaRegistry implements YangSchemaRegistry {
private static final String SYSTEM = SLASH + "system" + SLASH;
private static final String MAVEN = "mvn:";
private static final String JAR = ".jar";
private static final String USER_DIRECTORY = "user.dir";
private static final String AT = "@";
private static final String DATE_FORMAT = "yyyy-mm-dd";
private static final String ONOS = "org.onosproject";
private static final Logger log = getLogger(MockYangSchemaRegistry.class);
private static final String FS = File.separator;
private static final String USER_DIR = System.getProperty("user.dir").replaceAll("ea1000driver", "ea1000yang");
// private static final String BUCK_OUT_DIR = "/buck-out/gen/drivers/microsemi/ea1000yang/";
private static final String BUCK_OUT_BIN_LOC =
"/buck-out/bin/drivers/microsemi/ea1000yang/"
+ "lib__onos-drivers-microsemi-ea1000yang__classes/YangMetaData.ser";
private static final String PATH = FS + "target" + FS + "classes" + FS;
private static final String SER_FILE_PATH = "yang" + FS + "resources" +
FS + "YangMetaData.ser";
private static final String RESOURCE = "src/test/resources";
/*
* Map for storing app objects.
*/
private final ConcurrentMap<String, Object> appObjectStore;
/*
* Map for storing YANG schema nodes.
*/
private final ConcurrentMap<String, ConcurrentMap<String, YangSchemaNode>>
yangSchemaStore;
/*
* Map for storing YANG schema nodes with respect to root's generated
* interface file name.
*/
private final ConcurrentMap<String, YangSchemaNode> interfaceNameKeyStore;
/*
* Map for storing YANG schema nodes root's generated op param file name.
*/
private final ConcurrentMap<String, YangSchemaNode> opParamNameKeyStore;
/*
* Map for storing YANG schema nodes with respect to notifications.
*/
private final ConcurrentMap<String, YangSchemaNode> eventNameKeyStore;
/*
* Map for storing YANG schema nodes with respect to app name.
*/
private final ConcurrentMap<String, YangSchemaNode> appNameKeyStore;
/*
* Map for storing registered classes.
*/
private final ConcurrentMap<String, Class<?>> registerClassStore;
/*
* Map for storing YANG file details.
*/
private final ConcurrentMap<YangModuleIdentifier, String> yangFileStore;
/**
* Map for storing schema nodes with respect to namespace.
*/
private final ConcurrentMap<String, YangSchemaNode> nameSpaceSchemaStore;
private final ConcurrentMap<Object, Boolean> ynhRegistrationStore;
private final ConcurrentMap<String, String> jarPathStore;
/**
* Creates an instance of default YANG schema registry.
*/
public MockYangSchemaRegistry() {
appObjectStore = new ConcurrentHashMap<>();
yangSchemaStore = new ConcurrentHashMap<>();
interfaceNameKeyStore = new ConcurrentHashMap<>();
opParamNameKeyStore = new ConcurrentHashMap<>();
eventNameKeyStore = new ConcurrentHashMap<>();
registerClassStore = new ConcurrentHashMap<>();
yangFileStore = new ConcurrentHashMap<>();
appNameKeyStore = new ConcurrentHashMap<>();
ynhRegistrationStore = new ConcurrentHashMap<>();
jarPathStore = new ConcurrentHashMap<>();
nameSpaceSchemaStore = new ConcurrentHashMap<>();
}
/**
* This is overridden for Maven and Buck.
*
* Because they don't have a Bundle Context, and the JAR file doesn't exist
* when this is called, we have to work with the .ser file
*/
@Override
public void registerApplication(Object appObject, Class<?> serviceClass) {
synchronized (MockYangSchemaRegistry.class) {
doPreProcessing(serviceClass, appObject);
if (!verifyIfApplicationAlreadyRegistered(serviceClass)) {
List<YangNode> curNodes = new ArrayList<>();
Path serFile = Paths.get(USER_DIR, PATH, SER_FILE_PATH);
if (USER_DIR.contains("ea1000yang")) {
serFile = Paths.get(USER_DIR, PATH, SER_FILE_PATH);
} else {
serFile = Paths.get(USER_DIR, BUCK_OUT_BIN_LOC);
}
if (Files.notExists(serFile)) {
throw new UncheckedIOException(
new IOException("File " + serFile.toString() + " does not exist!"));
}
try {
curNodes.addAll(deSerializeDataModel(serFile.toString()));
} catch (IOException e) {
throw new UncheckedIOException(e);
}
// process application registration.
if (curNodes != null && !curNodes.isEmpty()) {
jarPathStore.put(serviceClass.getName(), serFile.toString());
processRegistration(serviceClass, serFile.toString(),
curNodes, appObject, false);
} else {
throw new UncheckedIOException(
new IOException("Unable to find Yang Nodes in serFile: " + serFile.toString()));
}
}
}
}
@Override
public void unRegisterApplication(Object managerObject,
Class<?> serviceClass) {
synchronized (MockYangSchemaRegistry.class) {
YangSchemaNode curNode;
String serviceName = serviceClass.getName();
//Check if service should be unregistered?
if (managerObject != null) {
verifyApplicationRegistration(managerObject, serviceClass);
}
//Remove registered class from store.
registerClassStore.remove(serviceName);
//check if service is in app store.
curNode = appNameKeyStore.get(serviceName);
if (curNode == null) {
curNode = interfaceNameKeyStore.get(serviceName);
}
if (curNode != null) {
removeSchemaNode(curNode);
eventNameKeyStore.remove(getEventClassName(curNode));
appObjectStore.remove(serviceName);
interfaceNameKeyStore.remove(getInterfaceClassName(curNode));
opParamNameKeyStore.remove(getOpParamClassName(curNode));
yangFileStore.remove(getModuleIdentifier(curNode));
appNameKeyStore.remove(serviceName);
nameSpaceSchemaStore.remove(curNode.getNameSpace()
.getModuleNamespace());
removeYsrGeneratedTemporaryResources(jarPathStore.get(serviceName),
serviceName);
log.info(" service {} is unregistered.",
serviceClass.getSimpleName());
} else {
throw new RuntimeException(serviceClass.getSimpleName() +
" service was not registered.");
}
}
}
@Override
public Object getRegisteredApplication(YangSchemaNode schemaNode) {
Object obj = null;
if (schemaNode != null) {
String name = getServiceName(schemaNode);
obj = appObjectStore.get(name);
if (obj == null) {
log.error("{} not found.", name);
}
}
return obj;
}
@Override
public YangSchemaNode getYangSchemaNodeUsingSchemaName(String schemaName) {
return getSchemaNodeUsingSchemaNameWithRev(schemaName);
}
@Override
public YangSchemaNode getYangSchemaNodeUsingAppName(String appName) {
YangSchemaNode node = appNameKeyStore.get(appName);
if (node == null) {
log.error("{} not found.", appName);
}
return node;
}
@Override
public YangSchemaNode
getYangSchemaNodeUsingGeneratedRootNodeInterfaceFileName(String name) {
YangSchemaNode node = interfaceNameKeyStore.get(name);
if (node == null) {
log.error("{} not found.", name);
}
return node;
}
@Override
public YangSchemaNode getYangSchemaNodeUsingGeneratedRootNodeOpPramFileName(
String name) {
YangSchemaNode node = opParamNameKeyStore.get(name);
if (node == null) {
log.error("{} not found.", name);
}
return node;
}
@Override
public YangSchemaNode getRootYangSchemaNodeForNotification(String name) {
YangSchemaNode node = eventNameKeyStore.get(name);
if (node == null) {
log.error("{} not found.", name);
}
return node;
}
@Override
public Class<?> getRegisteredClass(YangSchemaNode schemaNode) {
String interfaceName = getInterfaceClassName(schemaNode);
String serviceName = getServiceName(schemaNode);
Class<?> regClass = registerClassStore.get(serviceName);
if (regClass == null) {
regClass = registerClassStore.get(interfaceName);
}
return regClass;
}
@Override
public YangSchemaNode getSchemaWrtNameSpace(String nameSpace) {
YangSchemaNode node = nameSpaceSchemaStore.get(nameSpace);
if (node == null) {
log.error("node with {} namespace not found.", nameSpace);
}
return node;
}
@Override
public String getYangFile(YangModuleIdentifier moduleIdentifier) {
String file = yangFileStore.get(moduleIdentifier);
if (file == null) {
log.error("YANG files for corresponding module identifier {} not " +
"found", moduleIdentifier);
}
return file;
}
@Override
public boolean verifyNotificationObject(Object appObj, Class<?> service) {
synchronized (MockYangSchemaRegistry.class) {
YangSchemaNode node = appNameKeyStore.get(service.getName());
if (node == null) {
log.error("application is not registered with YMS {}",
service.getName());
return false;
}
try {
if (node.isNotificationPresent()) {
if (appObj != null) {
Boolean ifPresent = ynhRegistrationStore.get(appObj);
if (ifPresent == null) {
ynhRegistrationStore.put(appObj, true);
return true;
}
}
}
} catch (DataModelException e) {
log.error("notification registration error: {} {}", e
.getLocalizedMessage(), e);
}
return false;
}
}
@Override
public void flushYsrData() {
appObjectStore.clear();
yangSchemaStore.clear();
eventNameKeyStore.clear();
opParamNameKeyStore.clear();
interfaceNameKeyStore.clear();
registerClassStore.clear();
yangFileStore.clear();
nameSpaceSchemaStore.clear();
}
@Override
public void processModuleLibrary(String serviceName,
YangModuleLibrary library) {
synchronized (MockYangSchemaRegistry.class) {
YangSchemaNode node = appNameKeyStore.get(serviceName);
if (node != null) {
YangModuleInformation moduleInformation =
new DefaultYangModuleInformation(getModuleIdentifier(node),
node.getNameSpace());
addSubModuleIdentifier(node, (
DefaultYangModuleInformation) moduleInformation);
//TODO: add feature list to module information.
((DefaultYangModuleLibrary) library)
.addModuleInformation(moduleInformation);
}
}
}
/**
* Process service class.
*
* @param serviceClass service class
* @param appObject application object
*/
void doPreProcessing(Class<?> serviceClass, Object appObject) {
//Check if service should be registered?
if (appObject != null) {
verifyApplicationRegistration(appObject, serviceClass);
}
String name = serviceClass.getName();
//Add app class to registered service store.
if (!registerClassStore.containsKey(name)) {
registerClassStore.put(name, serviceClass);
}
}
void updateServiceClass(Class<?> service) {
registerClassStore.put(service.getName(), service);
}
/**
* Process application registration.
*
* @param service service class
* @param jarPath jar path
* @param nodes YANG nodes
* @param appObj application object
* @param isFromUt if registration is being called form unit test
*/
void processRegistration(Class<?> service, String jarPath,
List<YangNode> nodes,
Object appObj, boolean isFromUt) {
// process storing operations.
YangNode schemaNode = findNodeWhichShouldBeReg(service.getName(), nodes);
if (schemaNode != null) {
if (appObj != null) {
appObjectStore.put(service.getName(), appObj);
}
//Process application context for registrations.
processApplicationContext(schemaNode, service.getName(), isFromUt);
//Update YANG file store.
updateYangFileStore(schemaNode, jarPath);
}
}
/**
* Returns the node for which corresponding class is generated.
*
* @param name generated class name
* @param nodes list of yang nodes
* @return node for which corresponding class is generated
*/
private YangNode findNodeWhichShouldBeReg(String name, List<YangNode> nodes) {
for (YangNode node : nodes) {
if (name.equals(getServiceName(node)) ||
name.equals(getInterfaceClassName(node))) {
return node;
}
}
return null;
}
/**
* Verifies if service class should be registered or not.
*
* @param appObject application object
* @param appClass application class
*/
private void verifyApplicationRegistration(Object appObject,
Class<?> appClass) {
Class<?> managerClass = appObject.getClass();
Class<?>[] services = managerClass.getInterfaces();
List<Class<?>> classes = new ArrayList<>();
Collections.addAll(classes, services);
if (!classes.contains(appClass)) {
throw new RuntimeException("service class " + appClass.getName() +
"is not being implemented by " +
managerClass.getName());
}
}
/**
* Verifies if application is already registered with YMS.
*
* @param appClass application class
* @return true if application already registered
*/
private boolean verifyIfApplicationAlreadyRegistered(Class<?> appClass) {
String appName = appClass.getName();
return appObjectStore.containsKey(appName) ||
interfaceNameKeyStore.containsKey(appName);
}
/**
* Updates yang file store for YANG node.
*
* @param node YANG node
* @param jarPath jar file path
*/
private void updateYangFileStore(YangNode node, String jarPath) {
yangFileStore.put(getModuleIdentifier(node),
getYangFilePath(jarPath, node.getFileName()));
}
/**
* Returns yang file path.
*
* @param jarPath jar path
* @param metaDataFileName name of yang file from metadata
* @return yang file path
*/
private String getYangFilePath(String jarPath, String metaDataFileName) {
String[] metaData = metaDataFileName.split(SLASH);
return jarPath + SLASH + metaData[metaData.length - 1];
}
/**
* Process an application an updates the maps for YANG schema registry.
*
* @param appNode application YANG schema nodes
* @param name class name
* @param isFormUt if method is being called from unit tests
*/
private void processApplicationContext(YangSchemaNode appNode, String name,
boolean isFormUt) {
//Update map for which registrations is being called.
appNameKeyStore.put(name, appNode);
// Updates schema store.
addToSchemaStore(appNode);
// update interface store.
interfaceNameKeyStore.put(getInterfaceClassName(appNode), appNode);
//update op param store.
opParamNameKeyStore.put(getOpParamClassName(appNode), appNode);
//update namespaceSchema store.
nameSpaceSchemaStore.put(appNode.getNameSpace().getModuleNamespace(), appNode);
//Checks if notification is present then update notification store map.
String eventSubject = null;
try {
if (appNode.isNotificationPresent()) {
eventSubject = getEventClassName(appNode);
}
} catch (DataModelException e) {
log.error("failed to search notification from schema map : {}",
e.getLocalizedMessage());
}
if (eventSubject != null) {
eventNameKeyStore.put(eventSubject, appNode);
}
if (!isFormUt) {
log.info("successfully registered this application {}", name);
}
}
/**
* Returns jar path from bundle mvnLocationPath.
*
* @param mvnLocationPath mvnLocationPath of bundle
* @return path of jar
*/
private String getJarPathFromBundleLocation(String mvnLocationPath,
String currentDirectory) {
String path = currentDirectory + SYSTEM;
if (mvnLocationPath.contains(MAVEN)) {
String[] strArray = mvnLocationPath.split(MAVEN);
if (strArray[1].contains(File.separator)) {
String[] split = strArray[1].split(File.separator);
if (split[0].contains(PERIOD)) {
String[] groupId = split[0].split(Pattern.quote(PERIOD));
return path + groupId[0] + SLASH + groupId[1] + SLASH + split[1] +
SLASH + split[2] + SLASH + split[1] + HYPHEN + split[2];
}
}
}
return null;
}
/**
* Returns schema node based on the revision.
*
* @param name name of the schema node
* @return schema node based on the revision
*/
private YangSchemaNode getSchemaNodeUsingSchemaNameWithRev(String name) {
ConcurrentMap<String, YangSchemaNode> revMap;
YangSchemaNode schemaNode;
if (name.contains(AT)) {
String[] revArray = name.split(AT);
revMap = yangSchemaStore.get(revArray[0]);
schemaNode = revMap.get(name);
if (schemaNode == null) {
log.error("{} not found.", name);
}
return schemaNode;
}
if (yangSchemaStore.containsKey(name)) {
revMap = yangSchemaStore.get(name);
if (revMap != null && !revMap.isEmpty()) {
YangSchemaNode node = revMap.get(name);
if (node != null) {
return node;
}
String revName = getLatestVersion(revMap);
return revMap.get(revName);
}
}
log.error("{} not found.", name);
return null;
}
private String getLatestVersion(ConcurrentMap<String, YangSchemaNode> revMap) {
List<String> keys = new ArrayList<>();
for (Map.Entry<String, YangSchemaNode> entry : revMap.entrySet()) {
keys.add(entry.getKey());
}
sort(keys);
return keys.get(keys.size() - 1);
}
/**
* Adds schema node when different revision of node has received.
*
* @param schemaNode schema node
*/
private void addToSchemaStore(YangSchemaNode schemaNode) {
String date = getDateInStringFormat(schemaNode);
String name = schemaNode.getName();
String revName = name;
if (date != null) {
revName = name + AT + date;
}
//check if already present.
if (!yangSchemaStore.containsKey(name)) {
ConcurrentMap<String, YangSchemaNode> revStore =
new ConcurrentHashMap<>();
revStore.put(revName, schemaNode);
yangSchemaStore.put(name, revStore);
} else {
yangSchemaStore.get(name).put(revName, schemaNode);
}
}
/**
* Returns date in string format.
*
* @param schemaNode schema node
* @return date in string format
*/
String getDateInStringFormat(YangSchemaNode schemaNode) {
if (schemaNode != null) {
if (((YangNode) schemaNode).getRevision() != null) {
return new SimpleDateFormat(DATE_FORMAT)
.format(((YangNode) schemaNode).getRevision()
.getRevDate());
}
}
return null;
}
/**
* Removes schema node from schema map.
*
* @param removableNode schema node which needs to be removed
*/
private void removeSchemaNode(YangSchemaNode removableNode) {
String name = removableNode.getName();
String revName = name;
String date = getDateInStringFormat(removableNode);
if (date != null) {
revName = name + AT + date;
}
ConcurrentMap<String, YangSchemaNode> revMap = yangSchemaStore.get(name);
if (revMap != null && !revMap.isEmpty() && revMap.size() != 1) {
revMap.remove(revName);
} else {
yangSchemaStore.remove(removableNode.getName());
}
}
/**
* Adds sub module identifier.
*
* @param node schema node
* @param information module information
*/
private void addSubModuleIdentifier(
YangSchemaNode node, DefaultYangModuleInformation information) {
List<YangInclude> includeList = new ArrayList<>();
if (node instanceof YangModule) {
includeList = ((YangModule) node).getIncludeList();
} else if (node instanceof YangSubModule) {
includeList = ((YangSubModule) node).getIncludeList();
}
for (YangInclude include : includeList) {
information.addSubModuleIdentifiers(getModuleIdentifier(
include.getIncludedNode()));
}
}
/**
* Returns module identifier for schema node.
*
* @param schemaNode schema node
* @return module identifier for schema node
*/
private YangModuleIdentifier getModuleIdentifier(
YangSchemaNode schemaNode) {
return new DefaultYangModuleIdentifier(
schemaNode.getName(), getDateInStringFormat(schemaNode));
}
/**
* Returns schema node's generated interface class name.
*
* @param schemaNode schema node
* @return schema node's generated interface class name
*/
String getInterfaceClassName(YangSchemaNode schemaNode) {
return schemaNode.getJavaPackage() + PERIOD +
getCapitalCase(schemaNode.getJavaClassNameOrBuiltInType());
}
/**
* Returns schema node's generated op param class name.
*
* @param schemaNode schema node
* @return schema node's generated op param class name
*/
private String getOpParamClassName(YangSchemaNode schemaNode) {
return getInterfaceClassName(schemaNode) + OP_PARAM;
}
/**
* Returns schema node's generated event class name.
*
* @param schemaNode schema node
* @return schema node's generated event class name
*/
private String getEventClassName(YangSchemaNode schemaNode) {
return getInterfaceClassName(schemaNode).toLowerCase() + PERIOD +
getCapitalCase(schemaNode.getJavaClassNameOrBuiltInType()) +
EVENT_STRING;
}
/**
* Returns schema node's generated service class name.
*
* @param schemaNode schema node
* @return schema node's generated service class name
*/
String getServiceName(YangSchemaNode schemaNode) {
return getInterfaceClassName(schemaNode) + SERVICE;
}
/**
* Removes YSR generated temporary resources.
*
* @param rscPath resource path
* @param appName application name
*/
private void removeYsrGeneratedTemporaryResources(String rscPath,
String appName) {
if (rscPath != null) {
File jarPath = new File(rscPath);
if (jarPath.exists()) {
try {
deleteDirectory(jarPath);
} catch (IOException e) {
log.error("failed to delete ysr resources for {} : {}",
appName, e.getLocalizedMessage());
}
}
}
}
}