From d1569975bb18f4359fac18aa98f55b69c248a3ad Mon Sep 17 00:00:00 2001 From: "Chinthakayala, Sheshashailavas (sc2914)" Date: Mon, 28 Aug 2017 05:25:46 -0900 Subject: [CCSDK-28] populated the seed code for dgbuilder updated the code to point to the new package name for sli Change-Id: I3b5a1d05dc5193664fd4a667afdcd0b2354010a4 Issue-ID:{CCSDK-28} Signed-off-by: Chinthakayala, Sheshashailavas (sc2914) Signed-off-by: Chinthakayala, Sheshashailavas (sc2914) --- dgbuilder/tools/FormatXml.java | 49 + dgbuilder/tools/PrintYangToProp.java | 1424 +++++++++++++++++++++++++++ dgbuilder/tools/dot_to_json.js | 138 +++ dgbuilder/tools/formatXml.py | 11 + dgbuilder/tools/format_json.sh | 6 + dgbuilder/tools/format_xml.sh | 16 + dgbuilder/tools/generate_props_from_yang.sh | 96 ++ dgbuilder/tools/getModuleName.sh | 2 + dgbuilder/tools/getRpcsClassFromYang.sh | 85 ++ dgbuilder/tools/jsonTool.js | 119 +++ dgbuilder/tools/json_to_html | 139 +++ dgbuilder/tools/json_to_html_table | 144 +++ dgbuilder/tools/json_to_prop | 116 +++ dgbuilder/tools/output_js/.gitignore | 2 + dgbuilder/tools/pom.xml_base | 79 ++ dgbuilder/tools/printYangProps.sh | 8 + dgbuilder/tools/printYangToProp.jar | Bin 0 -> 9010 bytes dgbuilder/tools/rs | 2 + dgbuilder/tools/setClasspath | 13 + 19 files changed, 2449 insertions(+) create mode 100644 dgbuilder/tools/FormatXml.java create mode 100644 dgbuilder/tools/PrintYangToProp.java create mode 100644 dgbuilder/tools/dot_to_json.js create mode 100644 dgbuilder/tools/formatXml.py create mode 100755 dgbuilder/tools/format_json.sh create mode 100755 dgbuilder/tools/format_xml.sh create mode 100755 dgbuilder/tools/generate_props_from_yang.sh create mode 100755 dgbuilder/tools/getModuleName.sh create mode 100755 dgbuilder/tools/getRpcsClassFromYang.sh create mode 100644 dgbuilder/tools/jsonTool.js create mode 100644 dgbuilder/tools/json_to_html create mode 100755 dgbuilder/tools/json_to_html_table create mode 100755 dgbuilder/tools/json_to_prop create mode 100644 dgbuilder/tools/output_js/.gitignore create mode 100644 dgbuilder/tools/pom.xml_base create mode 100755 dgbuilder/tools/printYangProps.sh create mode 100644 dgbuilder/tools/printYangToProp.jar create mode 100755 dgbuilder/tools/rs create mode 100755 dgbuilder/tools/setClasspath (limited to 'dgbuilder/tools') diff --git a/dgbuilder/tools/FormatXml.java b/dgbuilder/tools/FormatXml.java new file mode 100644 index 00000000..7c6915f7 --- /dev/null +++ b/dgbuilder/tools/FormatXml.java @@ -0,0 +1,49 @@ +import javax.xml.transform.*; +import javax.xml.transform.stream.*; +import java.io.*; +import java.util.*; +import java.nio.file.Paths; +import java.nio.file.Files; +import java.nio.charset.StandardCharsets; +import java.nio.charset.Charset; +public class FormatXml{ +public static String formatXml(String input, int indent) { + try { + Source xmlInput = new StreamSource(new StringReader(input)); + StringWriter stringWriter = new StringWriter(); + StreamResult xmlOutput = new StreamResult(stringWriter); + TransformerFactory transformerFactory = TransformerFactory.newInstance(); + transformerFactory.setAttribute("indent-number", indent); + Transformer transformer = transformerFactory.newTransformer(); + transformer.setOutputProperty(OutputKeys.INDENT, "yes"); + transformer.transform(xmlInput, xmlOutput); + return xmlOutput.getWriter().toString(); + } catch (Exception e) { + throw new RuntimeException(e); // simple exception handling, please review it + } +} + +public static String prettyFormat(String input) { + return formatXml(input, 2); +} + +public static String readFile(String path, Charset encoding) + throws IOException +{ + byte[] encoded = Files.readAllBytes(Paths.get(path)); + return new String(encoded, encoding); +} + +public static void main(String[] args){ +try{ + if (args != null && args.length != 1){ + System.out.println("Usage:java FormatXml xmlStr"); + System.exit(-1); + } + String xmlStr = readFile(args[0], StandardCharsets.UTF_8); + System.out.println(prettyFormat(xmlStr)); +}catch(Exception e){ + e.printStackTrace(); +} +} +} diff --git a/dgbuilder/tools/PrintYangToProp.java b/dgbuilder/tools/PrintYangToProp.java new file mode 100644 index 00000000..93aaac79 --- /dev/null +++ b/dgbuilder/tools/PrintYangToProp.java @@ -0,0 +1,1424 @@ + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.PrintStream; +import java.io.FileDescriptor; +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.LinkedList; +import java.util.List; +import java.util.Properties; +import java.util.Arrays; +import java.util.ArrayList; +import java.io.*; +import javax.json.*; +import org.opendaylight.yangtools.yang.binding.Identifier; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddressBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.CaseFormat; + +public class PrintYangToProp { + + private static final Logger LOG = LoggerFactory.getLogger(PrintYangToProp.class); + public static final String PROPERTIES_FILE="/opt/bvc/controller/configuration/flowred.properties"; + private static Properties properties; + + static { + + // Trick class loader into loading builders. Some of + // these will be needed later by Reflection classes, but need + // to explicitly "new" them here to get class loader to load them. +/* + ServiceInformationBuilder b2 = new ServiceInformationBuilder(); + ServiceDataBuilder b3 = new ServiceDataBuilder(); + SdncRequestHeaderBuilder b4 = new SdncRequestHeaderBuilder(); + RequestInformationBuilder b6 = new RequestInformationBuilder(); + + FlowredGroupInformationDataBuilder b29 = new FlowredGroupInformationDataBuilder(); + FlowredInformationDataBuilder b48 = new FlowredInformationDataBuilder(); + + OperStatusBuilder b41 = new OperStatusBuilder(); +*/ + + + } + + public static void loadProperties() { + /* + + File file = new File(PROPERTIES_FILE); + properties = new Properties(); + InputStream input = null; + if (file.isFile() && file.canRead()) { + try { + input = new FileInputStream(file); + properties.load(input); + LOG.info("Loaded properties from " + PROPERTIES_FILE ); + } catch (Exception e) { + LOG.error("Failed to load properties " + PROPERTIES_FILE +"\n",e); + } finally { + if (input != null) { + try { + input.close(); + } catch (IOException e) { + LOG.error("Failed to close properties file " + PROPERTIES_FILE +"\n",e); + } + } + } + } + */ + } + + public static Properties toProperties(Properties props, Object fromObj) { + Class fromClass = null; + + if (fromObj != null) + { + fromClass = fromObj.getClass(); + } + return (toProperties(props, "", fromObj, fromClass)); + } + + public static Properties toProperties(Properties props, String pfx, Object fromObj) + { + Class fromClass = null; + + if (fromObj != null) + { + fromClass = fromObj.getClass(); + } + + return(toProperties(props, pfx, fromObj, fromClass)); + } + + public static Properties toProperties(Properties props, String pfx, + Object fromObj, Class fromClass) { + + if (fromObj == null) { + return (props); + } + + + String simpleName = fromClass.getSimpleName(); + + //LOG.debug("Extracting properties from " + fromClass.getName() + // + " class"); + if (fromObj instanceof List) { + + // Class is a List. List should contain yang-generated classes. + //LOG.debug(fromClass.getName() + " is a List"); + + List fromList = (List) fromObj; + + for (int i = 0; i < fromList.size(); i++) { + toProperties(props, pfx + "[" + i + "]", fromList.get(i), fromClass); + } + props.setProperty(pfx + "_length", "" + fromList.size()); + + } else if (isYangGenerated(fromClass)) { + // Class is yang generated. + //LOG.debug(fromClass.getName() + " is a Yang-generated class"); + + String propNamePfx = null; + + // If called from a list (so prefix ends in ']'), don't + // add class name again + if (pfx.endsWith("]")) { + propNamePfx = pfx; + } else { + if ((pfx != null) && (pfx.length() > 0)) { + propNamePfx = pfx ; + } else { + propNamePfx = toLowerHyphen(fromClass.getSimpleName()); + } + + if (propNamePfx.endsWith("-builder")) { + propNamePfx = propNamePfx.substring(0, propNamePfx.length() + - "-builder".length()); + } + + if (propNamePfx.endsWith("-impl")) { + propNamePfx = propNamePfx.substring(0, propNamePfx.length() + - "-impl".length()); + } + } + + // Iterate through getter methods to figure out values we need to + // save from + + for (Method m : fromClass.getMethods()) { + // LOG.debug("Checking " + m.getName() + " method"); + if (isGetter(m)) { + // LOG.debug(m.getName() + " is a getter"); + Class returnType = m.getReturnType(); + String fieldName = toLowerHyphen(m.getName().substring(3)); + if(m != null && m.getName().matches("^is[A-Z].*")){ + fieldName = toLowerHyphen(m.getName().substring(2)); + } + + fieldName = fieldName.substring(0, 1).toLowerCase() + + fieldName.substring(1); + + // Is the return type a yang generated class? + if (isYangGenerated(returnType)) { + // Is it an enum? + if (returnType.isEnum()) { + // Return type is a typedef. Save its value. + try { + boolean isAccessible = m.isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + + Object retValue = m.invoke(fromObj); + + if (!isAccessible) { + m.setAccessible(isAccessible); + } + if (retValue != null) { + String propName = propNamePfx + "." + + fieldName; + String propVal = retValue.toString(); + String yangProp = "yang." + fieldName + "." + propVal; + if ( properties.containsKey(yangProp)) { + propVal = properties.getProperty(yangProp); + //LOG.debug("Adjusting property " + yangProp + " " + propVal); + } + //LOG.debug("Setting property " + propName + // + " to " + propVal); + props.setProperty(propName, propVal); + } + } catch (Exception e) { + LOG.error( + "Caught exception trying to convert Yang-generated enum returned by " + + fromClass.getName() + "." + + m.getName() + + "() to Properties entry", e); + } + } else if (isIpv4Address(returnType)) { + // Save its value + try { + String propName = propNamePfx + "." + fieldName; + boolean isAccessible = m.isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + Ipv4Address retValue = (Ipv4Address) m.invoke(fromObj); + if (!isAccessible) { + m.setAccessible(isAccessible); + } + + if (retValue != null) { + String propVal = retValue.getValue().toString(); + //LOG.debug("Setting property " + propName + // + " to " + propVal); + props.setProperty(propName, propVal); + + } + } catch (Exception e) { + LOG.error( + "Caught exception trying to convert value returned by " + + fromClass.getName() + "." + + m.getName() + + "() to Properties entry", e); + } + } else if (isIpv6Address(returnType)) { + // Save its value + try { + String propName = propNamePfx + "." + fieldName; + boolean isAccessible = m.isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + Ipv6Address retValue = (Ipv6Address) m.invoke(fromObj); + if (!isAccessible) { + m.setAccessible(isAccessible); + } + + if (retValue != null) { + String propVal = retValue.getValue().toString(); + //LOG.debug("Setting property " + propName + // + " to " + propVal); + props.setProperty(propName, propVal); + + } + } catch (Exception e) { + LOG.error( + "Caught exception trying to convert value returned by " + + fromClass.getName() + "." + + m.getName() + + "() to Properties entry", e); + } + } else { + try { + boolean isAccessible = m.isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + Object retValue = m.invoke(fromObj); + if (!isAccessible) { + m.setAccessible(isAccessible); + } + if (retValue != null) { + toProperties(props, propNamePfx + "." + fieldName, retValue, returnType); + } + } catch (Exception e) { + LOG.error( + "Caught exception trying to convert Yang-generated class returned by" + + fromClass.getName() + "." + + m.getName() + + "() to Properties entry", e); + } + } + } else if (returnType.equals(Class.class)) { + + //LOG.debug(m.getName() + // + " returns a Class object - not interested"); + + } else if (List.class.isAssignableFrom(returnType)) { + + // This getter method returns a list. + try { + boolean isAccessible = m.isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + Object retList = m.invoke(fromObj); + if (!isAccessible) { + m.setAccessible(isAccessible); + } + // Figure out what type of elements are stored in this array. + Type paramType = m.getGenericReturnType(); + Type elementType = ((ParameterizedType) paramType) + .getActualTypeArguments()[0]; + toProperties(props, propNamePfx + "." + fieldName, + retList, (Class)elementType); + } catch (Exception e) { + LOG.error( + "Caught exception trying to convert List returned by " + + fromClass.getName() + "." + + m.getName() + + "() to Properties entry", e); + } + + } else { + + // Method returns something that is not a List and not + // yang-generated. + // Save its value + try { + String propName = propNamePfx + "." + fieldName; + boolean isAccessible = m.isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + Object propValObj = m.invoke(fromObj); + if (!isAccessible) { + m.setAccessible(isAccessible); + } + + if (propValObj != null) { + String propVal = propValObj.toString(); + //LOG.debug("Setting property " + propName + // + " to " + propVal); + props.setProperty(propName, propVal); + + } + } catch (Exception e) { + LOG.error( + "Caught exception trying to convert value returned by " + + fromClass.getName() + "." + + m.getName() + + "() to Properties entry", e); + } + } + + } + } + + } else { + // Class is not yang generated and not a list + // Do nothing. + + } + + return (props); + } + + public static Object toBuilder(Properties props, Object toObj) { + + return (toBuilder(props, "", toObj)); + } + + public static List toList(Properties props, String pfx, List toObj, + Class elemType) { + + int maxIdx = -1; + boolean foundValue = false; + + //LOG.debug("Saving properties to List<" + elemType.getName() + // + "> from " + pfx); + + // Figure out array size + for (Object pNameObj : props.keySet()) { + String key = (String) pNameObj; + + if (key.startsWith(pfx + "[")) { + String idxStr = key.substring(pfx.length() + 1); + int endloc = idxStr.indexOf("]"); + if (endloc != -1) { + idxStr = idxStr.substring(0, endloc); + } + + try { + int curIdx = Integer.parseInt(idxStr); + if (curIdx > maxIdx) { + maxIdx = curIdx; + } + } catch (Exception e) { + LOG.error("Illegal subscript in property " + key); + } + + } + } + + //LOG.debug(pfx + " has max index of " + maxIdx); + for (int i = 0; i <= maxIdx; i++) { + + String curBase = pfx + "[" + i + "]"; + + if (isYangGenerated(elemType)) { + String builderName = elemType.getName() + "Builder"; + try { + Class builderClass = Class.forName(builderName); + Object builderObj = builderClass.newInstance(); + Method buildMethod = builderClass.getMethod("build"); + builderObj = toBuilder(props, curBase, builderObj, true); + if (builderObj != null) { + //LOG.debug("Calling " + builderObj.getClass().getName() + // + "." + buildMethod.getName() + "()"); + Object builtObj = buildMethod.invoke(builderObj); + toObj.add(builtObj); + foundValue = true; + } + + } catch (ClassNotFoundException e) { + LOG.warn("Could not find builder class " + builderName, e); + } catch (Exception e) { + LOG.error("Caught exception trying to populate list from " + + pfx); + } + } + + } + + if (foundValue) { + return (toObj); + } else { + return (null); + } + + } + + public static Object toBuilder(Properties props, String pfx, Object toObj) { + return(toBuilder(props, pfx, toObj, false)); + } + + public static Object toBuilder(Properties props, String pfx, Object toObj, boolean preservePfx) { + Class toClass = toObj.getClass(); + boolean foundValue = false; + + //LOG.debug("Saving properties to " + toClass.getName() + " class from " + // + pfx); + + Ipv4Address addr; + + if (isYangGenerated(toClass)) { + // Class is yang generated. + //LOG.debug(toClass.getName() + " is a Yang-generated class"); + + String propNamePfx = null; + if (preservePfx) { + propNamePfx = pfx; + } else { + + if ((pfx != null) && (pfx.length() > 0)) { + propNamePfx = pfx + "." + + toLowerHyphen(toClass.getSimpleName()); + } else { + propNamePfx = toLowerHyphen(toClass.getSimpleName()); + } + + if (propNamePfx.endsWith("-builder")) { + propNamePfx = propNamePfx.substring(0, propNamePfx.length() + - "-builder".length()); + } + + if (propNamePfx.endsWith("-impl")) { + propNamePfx = propNamePfx.substring(0, propNamePfx.length() + - "-impl".length()); + } + } + + if (toObj instanceof Identifier) { + //LOG.debug(toClass.getName() + " is a Key - skipping"); + return (toObj); + } + + // Iterate through getter methods to figure out values we need to + // set + + for (Method m : toClass.getMethods()) { + // LOG.debug("Is " + m.getName() + " method a setter?"); + if (isSetter(m)) { + // LOG.debug(m.getName() + " is a setter"); + Class paramTypes[] = m.getParameterTypes(); + Class paramClass = paramTypes[0]; + + String fieldName = toLowerHyphen(m.getName().substring(3)); + fieldName = fieldName.substring(0, 1).toLowerCase() + + fieldName.substring(1); + + String propName = propNamePfx + "." + fieldName; + + String paramValue = props.getProperty(propName); + if (paramValue == null) { + //LOG.debug(propName + " is unset"); + } else { + //LOG.debug(propName + " = " + paramValue); + } + + // Is the return type a yang generated class? + if (isYangGenerated(paramClass)) { + // Is it an enum? + if (paramClass.isEnum()) { + + //LOG.debug(m.getName() + " expects an Enum"); + // Param type is a typedef. + if (paramValue != null) { + Object paramObj = null; + + try { + paramObj = Enum.valueOf(paramClass, + toUpperCamelCase(paramValue)); + } catch (Exception e) { + LOG.error( + "Caught exception trying to convert field " + + propName + " to enum " + + paramClass.getName(), e); + } + + try { + boolean isAccessible = m.isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + + //LOG.debug("Calling " + // + toObj.getClass().getName() + "." + // + m.getName() + "(" + paramValue + // + ")"); + m.invoke(toObj, paramObj); + + if (!isAccessible) { + m.setAccessible(isAccessible); + } + foundValue = true; + + } catch (Exception e) { + LOG.error( + "Caught exception trying to create Yang-generated enum expected by" + + toClass.getName() + + "." + + m.getName() + + "() from Properties entry", + e); + } + } + } else { + + String simpleName = paramClass.getSimpleName(); + + if ("Ipv4Address".equals(simpleName) + || "Ipv6Address".equals(simpleName)) { + + if (paramValue != null) { + try { + IpAddress ipAddr = IpAddressBuilder + .getDefaultInstance(paramValue); + + + if ("Ipv4Address".equals(simpleName)) + { + m.invoke(toObj, ipAddr.getIpv4Address()); + } + else + { + m.invoke(toObj, ipAddr.getIpv6Address()); + + } + foundValue = true; + } catch (Exception e) { + LOG.error( + "Caught exception calling " + + toClass.getName() + "." + + m.getName() + "(" + + paramValue + ")", e); + + } + } + + } else { + // setter expects a yang-generated class. Need + // to + // create a builder to set it. + + String builderName = paramClass.getName() + + "Builder"; + Class builderClass = null; + Object builderObj = null; + Object paramObj = null; + + //LOG.debug(m.getName() + // + " expects a yang-generated class - looking for builder " + // + builderName); + try { + builderClass = Class.forName(builderName); + builderObj = builderClass.newInstance(); + paramObj = toBuilder(props, propNamePfx, + builderObj); + } catch (ClassNotFoundException e) { + Object constObj = null; + try { + // See if I can find a constructor I can + // use + Constructor[] constructors = paramClass + .getConstructors(); + // Is there a String constructor? + for (Constructor c : constructors) { + Class[] cParms = c + .getParameterTypes(); + if ((cParms != null) + && (cParms.length == 1)) { + if (String.class + .isAssignableFrom(cParms[0])) { + constObj = c + .newInstance(paramValue); + } + } + } + + if (constObj == null) { + // Is there a Long constructor? + for (Constructor c : constructors) { + Class[] cParms = c + .getParameterTypes(); + if ((cParms != null) + && (cParms.length == 1)) { + if (Long.class + .isAssignableFrom(cParms[0])) { + constObj = c + .newInstance(Long + .parseLong(paramValue)); + } + } + } + + } + + if (constObj != null) { + try { + m.invoke(toObj, constObj); + foundValue = true; + } catch (Exception e2) { + LOG.error( + "Caught exception trying to call " + + m.getName(), + e2); + } + } + } catch (Exception e1) { + LOG.warn( + "Could not find a suitable constructor for " + + paramClass.getName(), + e1); + } + + if (paramObj == null) { + LOG.warn("Could not find builder class " + + builderName + + " and could not find a String or Long constructor - trying just to set passing paramValue"); + + } + + } catch (Exception e) { + LOG.error( + "Caught exception trying to create builder " + + builderName, e); + } + + if (paramObj != null) { + + try { + + Method buildMethod = builderClass + .getMethod("build"); + //LOG.debug("Calling " + // + paramObj.getClass().getName() + // + "." + buildMethod.getName() + // + "()"); + Object builtObj = buildMethod + .invoke(paramObj); + + boolean isAccessible = m.isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + + //LOG.debug("Calling " + // + toObj.getClass().getName() + // + "." + m.getName() + "()"); + m.invoke(toObj, builtObj); + if (!isAccessible) { + m.setAccessible(isAccessible); + } + foundValue = true; + + } catch (Exception e) { + LOG.error( + "Caught exception trying to set Yang-generated class expected by" + + toClass.getName() + + "." + + m.getName() + + "() from Properties entry", + e); + } + } else { + try { + boolean isAccessible = m.isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + //LOG.debug("Calling " + // + toObj.getClass().getName() + // + "." + m.getName() + "(" + // + paramValue + ")"); + m.invoke(toObj, paramValue); + if (!isAccessible) { + m.setAccessible(isAccessible); + } + foundValue = true; + + } catch (Exception e) { + LOG.error( + "Caught exception trying to convert value returned by" + + toClass.getName() + + "." + + m.getName() + + "() to Properties entry", + e); + } + } + } + } + } else { + + // Setter's argument is not a yang-generated class. See + // if it is a List. + + if (List.class.isAssignableFrom(paramClass)) { + + //LOG.debug("Parameter class " + paramClass.getName() + // + " is a List"); + + // Figure out what type of args are in List and pass + // that to toList(). + + Type paramType = m.getGenericParameterTypes()[0]; + Type elementType = ((ParameterizedType) paramType) + .getActualTypeArguments()[0]; + Object paramObj = new LinkedList(); + try { + paramObj = toList(props, propName, + (List) paramObj, (Class) elementType); + } catch (Exception e) { + LOG.error("Caught exception trying to create list expected as argument to " + + toClass.getName() + "." + m.getName()); + } + + if (paramObj != null) { + try { + boolean isAccessible = m.isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + //LOG.debug("Calling " + // + toObj.getClass().getName() + "." + // + m.getName() + "(" + paramValue + // + ")"); + m.invoke(toObj, paramObj); + if (!isAccessible) { + m.setAccessible(isAccessible); + } + foundValue = true; + + } catch (Exception e) { + LOG.error( + "Caught exception trying to convert List returned by" + + toClass.getName() + "." + + m.getName() + + "() to Properties entry", + e); + } + } + } else { + + // Setter expects something that is not a List and + // not yang-generated. Just pass the parameter value + + //LOG.debug("Parameter class " + // + paramClass.getName() + // + " is not a yang-generated class or a List"); + + if (paramValue != null) { + + Object constObj = null; + + try { + // See if I can find a constructor I can use + Constructor[] constructors = paramClass + .getConstructors(); + // Is there a String constructor? + for (Constructor c : constructors) { + Class[] cParms = c.getParameterTypes(); + if ((cParms != null) + && (cParms.length == 1)) { + if (String.class + .isAssignableFrom(cParms[0])) { + constObj = c + .newInstance(paramValue); + } + } + } + + if (constObj == null) { + // Is there a Long constructor? + for (Constructor c : constructors) { + Class[] cParms = c + .getParameterTypes(); + if ((cParms != null) + && (cParms.length == 1)) { + if (Long.class + .isAssignableFrom(cParms[0])) { + constObj = c + .newInstance(Long + .parseLong(paramValue)); + } + } + } + + } + + if (constObj != null) { + try { + //LOG.debug("Calling " + // + toObj.getClass() + // .getName() + "." + // + m.getName() + "(" + // + constObj + ")"); + m.invoke(toObj, constObj); + foundValue = true; + } catch (Exception e2) { + LOG.error( + "Caught exception trying to call " + + m.getName(), e2); + } + } else { + try { + boolean isAccessible = m + .isAccessible(); + if (!isAccessible) { + m.setAccessible(true); + } + //LOG.debug("Calling " + // + toObj.getClass() + // .getName() + "." + // + m.getName() + "(" + // + paramValue + ")"); + m.invoke(toObj, paramValue); + if (!isAccessible) { + m.setAccessible(isAccessible); + } + foundValue = true; + + } catch (Exception e) { + LOG.error( + "Caught exception trying to convert value returned by" + + toClass.getName() + + "." + + m.getName() + + "() to Properties entry", + e); + } + } + } catch (Exception e1) { + LOG.warn( + "Could not find a suitable constructor for " + + paramClass.getName(), e1); + } + + /* + * try { boolean isAccessible = + * m.isAccessible(); if (!isAccessible) { + * m.setAccessible(true); } LOG.debug("Calling " + * + toObj.getClass().getName() + "." + + * m.getName() + "(" + paramValue + ")"); + * m.invoke(toObj, paramValue); if + * (!isAccessible) { + * m.setAccessible(isAccessible); } foundValue = + * true; + * + * } catch (Exception e) { LOG.error( + * "Caught exception trying to convert value returned by" + * + toClass.getName() + "." + m.getName() + + * "() to Properties entry", e); } + */ + } + } + } + } // End of section handling "setter" method + } // End of loop through Methods + } // End of section handling yang-generated class + + if (foundValue) { + return (toObj); + } else { + return (null); + } + } + +/* + public static void printPropertyList(PrintStream pstr, String pfx, + Class toClass) { + boolean foundValue = false; + + //LOG.debug("Analyzing " + toClass.getName() + " class : pfx " + pfx); + + if (isYangGenerated(toClass) + && (!Identifier.class.isAssignableFrom(toClass))) { + // Class is yang generated. + //LOG.debug(toClass.getName() + " is a Yang-generated class"); + + if (toClass.getName().endsWith("Key")) { + if (Identifier.class.isAssignableFrom(toClass)) { + //LOG.debug(Identifier.class.getName() + // + " is assignable from " + toClass.getName()); + } else { + + //LOG.debug(Identifier.class.getName() + // + " is NOT assignable from " + toClass.getName()); + } + } + + String propNamePfx = null; + if (pfx.endsWith("]")) { + propNamePfx = pfx; + } else { + + if ((pfx != null) && (pfx.length() > 0)) { + propNamePfx = pfx + "." + + toLowerHyphen(toClass.getSimpleName()); + } else { + propNamePfx = toLowerHyphen(toClass.getSimpleName()); + } + + if (propNamePfx.endsWith("-builder")) { + propNamePfx = propNamePfx.substring(0, propNamePfx.length() + - "-builder".length()); + } + + if (propNamePfx.endsWith("-impl")) { + propNamePfx = propNamePfx.substring(0, propNamePfx.length() + - "-impl".length()); + } + } + + // Iterate through getter methods to figure out values we need to + // set + + for (Method m : toClass.getMethods()) { + //LOG.debug("Is " + m.getName() + " method a getter?"); + if (isGetter(m)) { + //LOG.debug(m.getName() + " is a getter"); + Class returnClass = m.getReturnType(); + + String fieldName = toLowerHyphen(m.getName().substring(3)); + fieldName = fieldName.substring(0, 1).toLowerCase() + + fieldName.substring(1); + + String propName = propNamePfx + "." + fieldName; + + // Is the return type a yang generated class? + if (isYangGenerated(returnClass)) { + // Is it an enum? + if (returnClass.isEnum()) { + //System.out.println(returnClass.getSimpleName()); + //System.out.println(Arrays.asList(returnClass.getEnumConstants())); + + //LOG.debug(m.getName() + " is an Enum"); + pstr.print("\n" + propName + ":Enum:" + Arrays.asList(returnClass.getEnumConstants()) + "\n"); + + } else { + + String simpleName = returnClass.getSimpleName(); + + if ("Ipv4Address".equals(simpleName) || "Ipv6Address".equals(simpleName)) { + //LOG.debug(m.getName()+" is an "+simpleName); + pstr.print("\n" + propName + ":" + simpleName + "\n"); + } else { + printPropertyList(pstr, propNamePfx, returnClass); + } + + } + } else { + + // Setter's argument is not a yang-generated class. See + // if it is a List. + + if (List.class.isAssignableFrom(returnClass)) { + + //LOG.debug("Parameter class " + //+ returnClass.getName() + " is a List"); + + // Figure out what type of args are in List and pass + // that to toList(). + + Type returnType = m.getGenericReturnType(); + Type elementType = ((ParameterizedType) returnType) + .getActualTypeArguments()[0]; + Class elementClass = (Class) elementType; + //LOG.debug("Calling printPropertyList on list type (" + //+ elementClass.getName() + //+ "), pfx is (" + // + pfx + // + "), toClass is (" + // + toClass.getName() + ")"); + printPropertyList( + pstr, + propNamePfx + + "." + + toLowerHyphen(elementClass + .getSimpleName()) + "[]", + elementClass); + + } else if (!returnClass.equals(Class.class)) { + + // Setter expects something that is not a List and + // not yang-generated. Just pass the parameter value + + //LOG.debug("Parameter class " + // + returnClass.getName() + // + " is not a yang-generated class or a List"); + String className=returnClass.getName(); + + //"org.opendaylight.yangtools.yang.binding.Identifier" + int nClassNameIndex = className.lastIndexOf('.'); + String nClassName = className; + if(nClassNameIndex != -1){ + nClassName=className.substring(nClassNameIndex+1); + } + pstr.print("\n" + propName +":" + nClassName +"\n"); + + } + } + } // End of section handling "setter" method + } // End of loop through Methods + } // End of section handling yang-generated class + + } +*/ + + public static Properties prop = new Properties(); + public static ArrayList propList = new ArrayList(); + public static Properties getProperties(PrintStream pstr, String pfx, + Class toClass) { + boolean foundValue = false; + + //LOG.debug("Analyzing " + toClass.getName() + " class : pfx " + pfx); + + if (isYangGenerated(toClass) + && (!Identifier.class.isAssignableFrom(toClass))) { + // Class is yang generated. + //LOG.debug(toClass.getName() + " is a Yang-generated class"); + + if (toClass.getName().endsWith("Key")) { + if (Identifier.class.isAssignableFrom(toClass)) { + //LOG.debug(Identifier.class.getName() + // + " is assignable from " + toClass.getName()); + } else { + + //LOG.debug(Identifier.class.getName() + // + " is NOT assignable from " + toClass.getName()); + } + } + + String propNamePfx = null; + if (pfx.endsWith("]")) { + propNamePfx = pfx; + }else if(pfx.indexOf(".CLASS_FOUND") != -1){ + pfx = pfx.replace(".CLASS_FOUND",""); + propNamePfx = pfx + "." + + toLowerHyphen(toClass.getSimpleName()); + } else { + + if ((pfx != null) && (pfx.length() > 0)) { + propNamePfx = pfx + "." + + toLowerHyphen(toClass.getSimpleName()); + } else { + propNamePfx = toLowerHyphen(toClass.getSimpleName()); + } + + if (propNamePfx.endsWith("-builder")) { + propNamePfx = propNamePfx.substring(0, propNamePfx.length() + - "-builder".length()); + } + + if (propNamePfx.endsWith("-impl")) { + propNamePfx = propNamePfx.substring(0, propNamePfx.length() + - "-impl".length()); + } + } + + // Iterate through getter methods to figure out values we need to + // set + + for (Method m : toClass.getMethods()) { + //LOG.debug("Is " + m.getName() + " method a getter?"); + if (isGetter(m)) { + // LOG.debug(m.getName() + " is a getter"); + Class returnClass = m.getReturnType(); + + String fieldName = toLowerHyphen(m.getName().substring(3)); + if(m != null && m.getName().matches("^is[A-Z].*")){ + fieldName = toLowerHyphen(m.getName().substring(2)); + } + fieldName = fieldName.substring(0, 1).toLowerCase() + + fieldName.substring(1); + + String propName = propNamePfx + "." + fieldName; + //System.out.println("****" + propName); + + // Is the return type a yang generated class? + if (isYangGenerated(returnClass)) { + // Is it an enum? + if (returnClass.isEnum()) { + + //LOG.debug(m.getName() + " is an Enum"); + //pstr.print("\n" + propName); + //pstr.print("\n" + propName + ":Enum:" + Arrays.asList(returnClass.getEnumConstants()) + "\n"); + pstr.print("\"" + propName + ":Enum:" + Arrays.asList(returnClass.getEnumConstants()) + "\","); + prop.setProperty(propName,""); + propList.add(propName); + + } else { + + String simpleName = returnClass.getSimpleName(); + //System.out.println("simpleName:" + simpleName); + + if ("Ipv4Address".equals(simpleName) || "Ipv6Address".equals(simpleName) || "IpAddress".equals(simpleName)) { + //LOG.debug(m.getName()+" is an "+simpleName); + //pstr.print("\n" + propName); + //pstr.print("\n" + propName + ":" + simpleName + "\n"); + pstr.print("\"" + propName + ":" + simpleName + "\","); + prop.setProperty(propName,""); + propList.add(propName); + } else { + boolean isString = false; + boolean isNumber = false; + boolean isBoolean = false; + boolean isIdentifier = false; + //System.out.println("simpleName:" + simpleName); + //System.out.println("propName:" + propName); + for(Method mthd : returnClass.getMethods()){ + String methodName = mthd.getName(); + //System.out.println("methodName:" + methodName); + if(methodName.equals("getValue")){ + Class retType = mthd.getReturnType(); + //System.out.println("retType:" + retType); + isString = String.class.isAssignableFrom(retType); + isNumber = Number.class.isAssignableFrom(retType); + isBoolean = Boolean.class.isAssignableFrom(retType); + isIdentifier = Identifier.class.isAssignableFrom(retType); + //System.out.println("isString:" + isString); + //System.out.println("isNumber:" + isNumber); + //System.out.println("isNumber:" + isNumber); + break; + } + } + + if(isString){ + pstr.print("\"" + propName + ":String\","); + prop.setProperty(propName,""); + propList.add(propName); + }else if(isNumber){ + pstr.print("\"" + propName + ":Number\","); + prop.setProperty(propName,""); + propList.add(propName); + }else if(isBoolean){ + pstr.print("\"" + propName + ":Boolean\","); + prop.setProperty(propName,""); + propList.add(propName); + }else if(isIdentifier){ + //System.out.println("isIdentifier"); + //isIdentifer so skipping + continue; + }else{ + /* + System.out.println("fieldName:" + fieldName); + System.out.println("simpleName:" + simpleName); + System.out.println("returnClass:" + returnClass); + System.out.println("pstr:" + pstr); + System.out.println("propNamePfx:" + propNamePfx); + */ + getProperties(pstr, propNamePfx + ".CLASS_FOUND", returnClass); + } + } + + } + } else { + + // Setter's argument is not a yang-generated class. See + // if it is a List. + + if (List.class.isAssignableFrom(returnClass)) { + + //LOG.debug("Parameter class " + // + returnClass.getName() + " is a List"); + + // Figure out what type of args are in List and pass + // that to toList(). + + Type returnType = m.getGenericReturnType(); + Type elementType = ((ParameterizedType) returnType) + .getActualTypeArguments()[0]; + Class elementClass = (Class) elementType; + //LOG.debug("Calling printPropertyList on list type (" + //+ elementClass.getName() + // + "), pfx is (" + // + pfx + // + "), toClass is (" + // + toClass.getName() + ")"); + //System.out.println("List propNamePfx:" + propNamePfx+ "." + toLowerHyphen(elementClass.getSimpleName()) + "[]"); + if(String.class.isAssignableFrom(elementClass)){ + pstr.print("\"" + propName + ":[String,String,...]\","); + prop.setProperty(propName,""); + propList.add(propName); + }else if(Number.class.isAssignableFrom(elementClass)){ + pstr.print("\"" + propName + ":[Number,Number,...]\","); + prop.setProperty(propName,""); + propList.add(propName); + }else if(Boolean.class.isAssignableFrom(elementClass)){ + pstr.print("\"" + propName + ":[Boolean,Boolean,...]\","); + prop.setProperty(propName,""); + propList.add(propName); + }else if(Identifier.class.isAssignableFrom(elementClass)){ + continue; + }else{ + getProperties( + pstr, + propNamePfx + + "." + + toLowerHyphen(elementClass + .getSimpleName()) + "[]", + elementClass); + } + + } else if (!returnClass.equals(Class.class)) { + + // Setter expects something that is not a List and + // not yang-generated. Just pass the parameter value + + //LOG.debug("Parameter class " + // + returnClass.getName() + // + " is not a yang-generated class or a List"); + + //pstr.print("\n" + propName); + String className=returnClass.getName(); + int nClassNameIndex = className.lastIndexOf('.'); + String nClassName = className; + if(nClassNameIndex != -1){ + nClassName=className.substring(nClassNameIndex+1); + } + boolean isString = String.class.isAssignableFrom(returnClass); + boolean isNumber = Number.class.isAssignableFrom(returnClass); + boolean isBoolean = Boolean.class.isAssignableFrom(returnClass); + //pstr.print("\n" + propName +":" + nClassName +"\n"); + boolean isIdentifier = Identifier.class.isAssignableFrom(returnClass); + if(!isIdentifier && !nClassName.equals("[C")){ + if(isNumber){ + pstr.print("\"" + propName +":Number\","); + }else if(isBoolean){ + pstr.print("\"" + propName +":Boolean\","); + }else{ + if(nClassName.equals("[B")){ + pstr.print("\"" + propName +":Binary\","); + }else{ + pstr.print("\"" + propName +":" + nClassName +"\","); + } + } + prop.setProperty(propName,""); + propList.add(propName); + } + + } + } + } // End of section handling "setter" method + } // End of loop through Methods + } // End of section handling yang-generated class + + return prop; + } + + public static boolean isYangGenerated(Class c) { + if (c == null) { + return (false); + } else { + //System.out.println(c.getName()); + return (c.getName().startsWith("org.opendaylight.yang.gen.")); + } + } + + public static boolean isIpv4Address(Class c) { + + if (c == null ) { + return (false); + } + String simpleName = c.getSimpleName(); + return ("Ipv4Address".equals(simpleName)) ; + } + + public static boolean isIpv6Address(Class c) { + + if (c == null ) { + return (false); + } + String simpleName = c.getSimpleName(); + return ("Ipv6Address".equals(simpleName)) ; + } + + public static String toLowerHyphen(String inStr) { + if (inStr == null) { + return (null); + } + + String str = inStr.substring(0, 1).toLowerCase(); + if (inStr.length() > 1) { + str = str + inStr.substring(1); + } + + String regex = "(([a-z0-9])([A-Z]))"; + String replacement = "$2-$3"; + + String retval = str.replaceAll(regex, replacement).toLowerCase(); + + //LOG.debug("Converting " + inStr + " => " + str + " => " + retval); + return (retval); + } + + public static String toUpperCamelCase(String inStr) { + if (inStr == null) { + return (null); + } + + String[] terms = inStr.split("-"); + StringBuffer sbuff = new StringBuffer(); + // Check if string begins with a digit + if (Character.isDigit(inStr.charAt(0))) { + sbuff.append('_'); + } + for (String term : terms) { + sbuff.append(term.substring(0, 1).toUpperCase()); + if (term.length() > 1) { + sbuff.append(term.substring(1)); + } + } + return (sbuff.toString()); + + } + + public static boolean isGetter(Method m) { + //System.out.println(m); + if (m == null) { + return (false); + } + + if (Modifier.isPublic(m.getModifiers()) + && (m.getParameterTypes().length == 0)) { + if ((m.getName().matches("^is[A-Z].*") || m.getName().matches("^get[A-Z].*")) + && m.getReturnType().equals(Boolean.class)) { + return (true); + } + if (m.getName().matches("^get[A-Z].*") + && !m.getReturnType().equals(void.class)) { + return (true); + } + + } + + return (false); + } + + public static boolean isSetter(Method m) { + if (m == null) { + return (false); + } + + if (Modifier.isPublic(m.getModifiers()) + && (m.getParameterTypes().length == 1)) { + if (m.getName().matches("^set[A-Z].*")) { + Class[] paramTypes = m.getParameterTypes(); + if (paramTypes[0].isAssignableFrom(Identifier.class) + || Identifier.class.isAssignableFrom(paramTypes[0])) { + return (false); + } else { + return (true); + } + } + + } + + return (false); + } + + public static void main(String[] args){ + try{ + PrintStream ps = new PrintStream(new FileOutputStream(FileDescriptor.out)); + PrintYangToProp printYangToProp = new PrintYangToProp(); + String className = args[0]; + //ClassLoader classLoader = PrintYangToProp.class.getClassLoader(); + //Class aClass = classLoader.loadClass(className); + Class cl = Class.forName(className); + //printPropertyList(ps,"",cl); + //JsonObject jsonObj = Json.createObjectBuilder().build(); + Properties p = getProperties(ps,"",cl); + //System.out.println(p); + + }catch(Exception e){ + e.printStackTrace(); + } + } + + +} diff --git a/dgbuilder/tools/dot_to_json.js b/dgbuilder/tools/dot_to_json.js new file mode 100644 index 00000000..7ff80e8b --- /dev/null +++ b/dgbuilder/tools/dot_to_json.js @@ -0,0 +1,138 @@ +var obj={}; +function dotToJson(str,value,obj){ + //var objArr = path.split("."), part; + var objArr = str.split("."); + var prevStr; + var currObj; + var prevObj; + //console.log(str); + var isArray = false; + var prevObjIsArray = false; + for(var i=0;i${toolsDir}/tmpws/logs/err.log + echo "Usage: $0 yangFile" >>${toolsDir}/tmpws/logs/err.log + exit +fi + +isZipFile="N" +echo "$1" | grep "\.zip$" >/dev/null 2>&1 +if [ "$?" -eq "0" ] +then + isZipFile="Y" +fi + +if [ "$isZipFile" = "Y" ] +then + #zip file of yangs provided + zipFile=$(basename $1) + unzip -o -d $PROJECT_HOME/tools/tmpws/tmp $1 >/dev/null 2>&1 + rm $1 >/dev/null 2>&1 + cd $PROJECT_HOME/tools/tmpws/tmp + fName="${zipFile}" + extension="${fName##*.}" + moduleName="${fName%.*}" + #echo "ModuleName is :$moduleName" + rm -rf $PROJECT_HOME/yangFiles/$moduleName + mkdir $PROJECT_HOME/yangFiles/$moduleName + mv *.yang $PROJECT_HOME/yangFiles/$moduleName + cd $PROJECT_HOME/tools + yangFilesFullPath=${PROJECT_HOME}/yangFiles/$moduleName + cd ${toolsDir}/tmpws + mkdir -p yangApp/model/src/main/yang + mkdir -p yangApp/model/src/main/yang-gen-sal + cp -r ${yangFilesFullPath}/* yangApp/model/src/main/yang + cp ${toolsDir}/pom.xml_base yangApp/model/pom.xml + cd ${toolsDir}/tmpws/yangApp/model + + #Maven Compile + mvn clean install >${toolsDir}/tmpws/logs/mvn_install.log 2>${toolsDir}/tmpws/logs/err.log + yangApp_model_jar="yangApp-model-1.0.0-SNAPSHOT.jar" + + #Copy the built jar to jars directory + cp ${toolsDir}/tmpws/yangApp/model/target/${yangApp_model_jar} ${toolsDir}/tmpws/jars + . ${toolsDir}/setClasspath + + mv ${toolsDir}/output_js/${moduleName}_inputs.js ${toolsDir}/output_js/${moduleName}_inputs_prev.js >/dev/null 2>&1 + + ${toolsDir}/getRpcsClassFromYang.sh ${yangFilesFullPath}/${moduleName}.yang ${toolsDir}/tmpws/yangApp/model/target/${yangApp_model_jar} > ${toolsDir}/output_js/${moduleName}.js + + node ${toolsDir}/dot_to_json.js ${toolsDir}/output_js/${moduleName}.js $moduleName >${toolsDir}/output_js/${moduleName}_inputs.js + + cp ${toolsDir}/output_js/${moduleName}_inputs.js $PROJECT_HOME/generatedJS +else + #Single yang provided + yangFileFullPath=$1 + cd ${toolsDir}/tmpws + mkdir -p yangApp/model/src/main/yang + mkdir -p yangApp/model/src/main/yang-gen-sal + cp ${yangFileFullPath} yangApp/model/src/main/yang + cp ${toolsDir}/pom.xml_base yangApp/model/pom.xml + cd ${toolsDir}/tmpws/yangApp/model + + #Maven Compile + mvn clean install >${toolsDir}/tmpws/logs/mvn_install.log 2>${toolsDir}/tmpws/logs/err.log + yangApp_model_jar="yangApp-model-1.0.0-SNAPSHOT.jar" + + #Copy the built jar to jars directory + cp ${toolsDir}/tmpws/yangApp/model/target/${yangApp_model_jar} ${toolsDir}/tmpws/jars + . ${toolsDir}/setClasspath + + moduleName=$(cat $yangFileFullPath|egrep "module .*{"|cut -d' ' -f2|cut -d'{' -f1) + + mv ${toolsDir}/output_js/${moduleName}_inputs.js ${toolsDir}/output_js/${moduleName}_inputs_prev.js >/dev/null 2>&1 + + ${toolsDir}/getRpcsClassFromYang.sh ${yangFileFullPath} ${toolsDir}/tmpws/yangApp/model/target/${yangApp_model_jar} > ${toolsDir}/output_js/${moduleName}.js + + node ${toolsDir}/dot_to_json.js ${toolsDir}/output_js/${moduleName}.js $moduleName >${toolsDir}/output_js/${moduleName}_inputs.js + + cp ${toolsDir}/output_js/${moduleName}_inputs.js $PROJECT_HOME/generatedJS + + +fi + +echo "Done..." + diff --git a/dgbuilder/tools/getModuleName.sh b/dgbuilder/tools/getModuleName.sh new file mode 100755 index 00000000..cf0db193 --- /dev/null +++ b/dgbuilder/tools/getModuleName.sh @@ -0,0 +1,2 @@ +module=$(cat $1|egrep "module .*{"|awk '{print $2}'|sed -e 's/{//g') +echo $module diff --git a/dgbuilder/tools/getRpcsClassFromYang.sh b/dgbuilder/tools/getRpcsClassFromYang.sh new file mode 100755 index 00000000..b0703152 --- /dev/null +++ b/dgbuilder/tools/getRpcsClassFromYang.sh @@ -0,0 +1,85 @@ +toolsDir=$PROJECT_HOME/tools +. ${toolsDir}/setClasspath +if [ "$#" != "2" ] +then + echo "Usage $0 yang_file generated_jar_file" + echo "example $0 /home/users/sdnc/src/sample.yang /home/users/sdnc/target/sample.model-1.0.0.jar" + exit +fi +yangFile="$1" +jarFile="$2" +module=$(cat $yangFile|egrep "module .*{"|awk '{print $2}'|sed -e 's/{//g') +#echo " \"$module\" : [" +rpcs=$(grep rpc $yangFile|grep -v leaf|sed -e 's/^\s\+rpc//g'|awk '{print $1}') +#echo ${rpcs} +for i in `find ${PROJECT_HOME}/svclogic/lib -name "*.jar" -print` +do +#echo $i +export CLASSPATH=$CLASSPATH:$i +done +export CLASSPATH=$CLASSPATH:${toolsDir}/printYangToProp.jar:. +allProps="" +for rpc in $rpcs +do +rpcVal=$(echo $rpc|sed -e "s/\b\(.\)/\u\1/g"|sed s/\-//g) +className=$(jar -tvf ${jarFile}|grep "org/opendaylight/yang/gen/"|grep -w "${rpcVal}Input.class"|grep -v grep|awk '{print $NF}'|sed -e 's/\//./g'|sed -e 's/.class$//g') +inputProps="" +if [ "$className" != "" ] +then + #java -cp $CLASSPATH PrintYangToProp $className 2>/dev/null|grep '*' |cut -d'*' -f2|sed -e "s/^[ \t]*//g"|sed -e "s/^/\t\t\"/g"|sed -e "s/$/\",/g" + inputProps=$(java -cp $CLASSPATH PrintYangToProp $className 2>${toolsDir}/tmpws/logs/err.log) +fi +className=$(jar -tvf ${jarFile}|grep "org/opendaylight/yang/gen/"|grep -w "${rpcVal}Output"|grep -v grep|awk '{print $NF}'|sed -e 's/\//./g'|sed -e 's/.class$//g') +#echo $inputProps +#echo $className +outputProps="" +if [ "$className" != "" ] +then + #java -cp $CLASSPATH PrintYangToProp $className 2>/dev/null|grep '*' |cut -d'*' -f2|sed -e "s/^[ \t]*//g"|sed -e "s/^/\t\t\"/g"|sed -e "s/$/\",/g" + outputProps=$(java -cp $CLASSPATH PrintYangToProp $className 2>${toolsDir}/tmpws/logs/err.log) +fi +if [ -z "$allProps" ] +then + allProps=$(echo ${inputProps}${outputProps}|sed -e s/,$//g) +else + allProps=$(echo ${allProps},${inputProps}${outputProps}|sed -e s/,$//g) +fi +done +#allProps=$(echo ${inputProps}${outputProps}|sed -e s/,$//g) +#echo $allProps +#OIFS=$IFS +#IFS=',' +#arr2=$allProps +#for x in $arr2 +#do +# echo "$x" +#done +#IFS=$OIFS +#echo " ]" +echo "module.exports = {" +echo "\"moduleName\" : \"${module}\"," +echo "'${module}_VALUES' : " +echo "[ $allProps ]"|python -m json.tool +echo "," +echo "'${module}_RPCS' : [" + +cnt=0 +#numOfRpcs=${#rpcs[@]} +numOfRpcs=0; +for rpc in $rpcs +do + numOfRpcs=$((numOfRpcs+1)) +done + +for rpc in $rpcs +do + cnt=$((cnt+1)) + if [ $cnt -eq $numOfRpcs ] + then + echo " \"$rpc\"" + else + echo " \"$rpc\"," + fi +done +echo " ]" +echo "}" diff --git a/dgbuilder/tools/jsonTool.js b/dgbuilder/tools/jsonTool.js new file mode 100644 index 00000000..d95ae10d --- /dev/null +++ b/dgbuilder/tools/jsonTool.js @@ -0,0 +1,119 @@ +var obj={}; +function dotToJson(str,value,obj){ + //var objArr = path.split("."), part; + var objArr = str.split("."); + var prevStr; + var currObj; + var prevObj; + //console.log(str); + var isArray = false; + var prevObjIsArray = false; + for(var i=0;i\" + document.getElementById(idVal).value + \"\";"; +htmlStr += " document.getElementById('displayId').innerHTML = val;"; +htmlStr += "document.getElementById('displayId').style.display = \"block\";"; +//htmlStr += "alert(idVal);"; +//htmlStr += "alert(val);"; +htmlStr += "}"; +htmlStr += ""; +htmlStr += ""; +htmlStr += ""; +htmlStr += "
\n\n"; +printObjectValues(jsonObj,level); +htmlStr += "\n
\n
"; +//var pattern = new RegExp("\\n","g"); +//htmlstr =htmlStr.replace(pattern,''); +htmlStr += ""; +console.log(htmlStr); + +function tabs(level){ +return ''; +} +function tabsOrig(level){ + var tabs=""; + for(var i=0;i\n" ; + objectHtmlStr += tabs(level+1 ) +"\n" ; + + var str=printObjectValues(v,level+2); + if(str != null && str != ''){ + htmlStr += tabs(level+2) + objectHtmlStr + "
" + key + "\n"; + htmlStr +="\n"; + } + + htmlStr += tabs(level+1) + "
\n" ; + htmlStr += tabs(level) + "\n"; + }else if(typeof v === 'object' && Array.isArray(v) === true){ + var idVal = objectId++; + level++; + objectHtmlStr += tabs(level) + "
\n"; + objectHtmlStr += tabs(level+1) + "\n"; + + var str = printArrayValues(v,key,level+2); + if(str != null && str != ''){ + htmlStr += tabs(level+2) + objectHtmlStr + "
" + key + "\n"; + htmlStr+="\n"; + } + + htmlStr += tabs(level+1) + "
\n" ; + htmlStr += tabs(level) + "
\n"; + }else{ + output += tabs(level) +"" + key + "" + printValue(v) + "\n"; + } + } +} +}catch(err){ + console.log(err); +} +return output; +} + +}catch(err){ +console.log( err ); +} + +function printArrayValues(arrObj,key,level){ +var output =""; +var arrayHtmlStr =""; +try{ + for(var i=0;arrObj != null && i\n" ; + arrayHtmlStr += tabs(level+1 ) +"\n" ; + + var str = printObjectValues(o,level+2); + if(str != null && str != ''){ + htmlStr += tabs(level+2 ) + arrayHtmlStr + "
" +key + "[" + i + "]" + "\n"; + htmlStr+="\n"; + } + htmlStr += tabs(level+1) + "
\n"; + htmlStr += tabs(level) + "\n"; + }else if(typeof o === 'object' && Array.isArray(v) === true){ + var idVal = objectId++; + level++; + arrayHtmlStr += tabs(level) + "
\n" ; + arrayHtmlStr += tabs(level+1 ) +"\n" ; + + var str = printArrayValues(o,key,level); + if(str != null && str != ''){ + htmlStr += tabs(level+2 ) + arrayHtmlStr + "
Array\n"; + htmlStr+="\n"; + } + + htmlStr += tabs(level+1) + "
\n"; + htmlStr += tabs(level) + "
\n"; + }else{ + output += tabs(level) + "" + printValue(o) + "\n"; + } + } +}catch(err){ + console.log(err); +} +return output; +} + +function printValue(obj){ + if(obj != undefined){ + return obj; + }else{ + return ""; + } +} diff --git a/dgbuilder/tools/json_to_html_table b/dgbuilder/tools/json_to_html_table new file mode 100755 index 00000000..20c9cfeb --- /dev/null +++ b/dgbuilder/tools/json_to_html_table @@ -0,0 +1,144 @@ +try{ +var jsonStr='{}'; +jsonObj=JSON.parse(jsonStr); +var htmlObj ={}; +var objectId =0; +var level=0; +var htmlStr="" +htmlStr += ""; +htmlStr += ""; +htmlStr += ""; +htmlStr += ""; +htmlStr += ""; +htmlStr += "
\n\n"; +console.log("
"); +printObjectValues(jsonObj,null,level); +console.log("
"); +htmlStr += "\n\n
"; +//var pattern = new RegExp("\\n","g"); +//htmlstr =htmlStr.replace(pattern,''); +htmlStr += ""; +//console.log(htmlStr); + +//console.dir(htmlObj); +var keyObj={}; +for (var key in htmlObj) { + var idx = key.lastIndexOf("."); + if(idx != -1){ + var str = key.substr(0,idx); + keyObj[str] =''; + }else{ + keyObj[key] =''; + } + //console.log(str); +} + +console.dir(keyObj); +console.log("
    "); +for (var key in keyObj) { + console.log("
  • " + key + "
    • "); +} +console.log("
"); + +function tabs(level){ +return ''; +} +function tabsOrig(level){ + var tabs=""; + for(var i=0;i" + pkey + "." + key + "" +printValue(v) + "" ); + htmlObj[pkey + "." + key ] = printValue(v); + }else{ + //console.log( key + ":" +printValue(v) ); + console.log("" + key + "" +printValue(v) + "" ); + htmlObj[key ] = printValue(v); + } + //printValue(v); + } + } +} +}catch(err){ + console.log(err); +} +return output; +} + +}catch(err){ +console.log( err ); +} + +function printArrayValues(arrObj,pkey,level){ +var output =""; +var arrayHtmlStr =""; +try{ + for(var i=0;arrObj != null && i" + pkey + "." + key + "" +printValue(o) + "" ); + htmlObj[pkey + "." + key ] = printValue(o); + //console.log(pkey + ":" +printValue(o) ); + //output += tabs(level) + "" + printValue(o) + "\n"; + } + } +}catch(err){ + console.log(err); +} +return output; +} + +function printValue(obj){ + if(obj != undefined){ + if(typeof obj == 'string'){ + return "'" + obj + "'"; + }else{ + return obj; + } + }else{ + return ""; + } +} diff --git a/dgbuilder/tools/json_to_prop b/dgbuilder/tools/json_to_prop new file mode 100755 index 00000000..f8830f38 --- /dev/null +++ b/dgbuilder/tools/json_to_prop @@ -0,0 +1,116 @@ +try{ +var jsonStr='{}'; +jsonObj=JSON.parse(jsonStr); +var htmlObj ={}; +var objectId =0; +var level=0; +var htmlStr="" +htmlStr += ""; +htmlStr += ""; +htmlStr += ""; +htmlStr += ""; +htmlStr += ""; +htmlStr += "
\n\n"; +printObjectValues(jsonObj,null,level); +htmlStr += "\n
\n
"; +//var pattern = new RegExp("\\n","g"); +//htmlstr =htmlStr.replace(pattern,''); +htmlStr += ""; +//console.log(htmlStr); + +function tabs(level){ +return ''; +} +function tabsOrig(level){ + var tabs=""; + for(var i=0;i" + printValue(o) + "\n"; + } + } +}catch(err){ + console.log(err); +} +return output; +} + +function printValue(obj){ + if(obj != undefined){ + if(typeof obj == 'string'){ + return "'" + obj + "'"; + }else{ + return obj; + } + }else{ + return ""; + } +} diff --git a/dgbuilder/tools/output_js/.gitignore b/dgbuilder/tools/output_js/.gitignore new file mode 100644 index 00000000..d6b7ef32 --- /dev/null +++ b/dgbuilder/tools/output_js/.gitignore @@ -0,0 +1,2 @@ +* +!.gitignore diff --git a/dgbuilder/tools/pom.xml_base b/dgbuilder/tools/pom.xml_base new file mode 100644 index 00000000..b54c27f6 --- /dev/null +++ b/dgbuilder/tools/pom.xml_base @@ -0,0 +1,79 @@ + + + 4.0.0 + + org.onap.ccsdk.distribution + distribution-root + 0.1.0-SNAPSHOT + + yangApp-model + bundle + 1.0.0-SNAPSHOT + + + + + org.apache.felix + maven-bundle-plugin + true + + + * + + + + + org.opendaylight.yangtools + yang-maven-plugin + ${odl.yangtools.yang.maven.plugin.version} + + + org.opendaylight.mdsal + maven-sal-api-gen-plugin + ${odl.sal.api.gen.plugin.version} + jar + + + + + + generate-sources + + + ${yang.file.directory} + + + org.opendaylight.yangtools.maven.sal.api.gen.plugin.CodeGeneratorImpl + ${salGeneratorPath} + + + true + + + + + + + + + org.opendaylight.mdsal + yang-binding + ${odl.mdsal.yang.binding.version} + + + org.opendaylight.yangtools + yang-common + ${odl.yangtools.version} + + + org.opendaylight.mdsal.model + ietf-inet-types + ${odl.ietf-inet-types.version} + + + org.opendaylight.mdsal.model + ietf-yang-types + ${odl.ietf-yang-types.version} + + + diff --git a/dgbuilder/tools/printYangProps.sh b/dgbuilder/tools/printYangProps.sh new file mode 100755 index 00000000..7d1d0faf --- /dev/null +++ b/dgbuilder/tools/printYangProps.sh @@ -0,0 +1,8 @@ +toolsDir=$PROJECT_HOME/tools +. ${toolsDir}/setClasspath +if [ "$#" != "1" ] +then + echo "Usage $0 className_without_the_dot_class_ext" + exit +fi + java PrintYangToProp $1 diff --git a/dgbuilder/tools/printYangToProp.jar b/dgbuilder/tools/printYangToProp.jar new file mode 100644 index 00000000..01b73107 Binary files /dev/null and b/dgbuilder/tools/printYangToProp.jar differ diff --git a/dgbuilder/tools/rs b/dgbuilder/tools/rs new file mode 100755 index 00000000..3d92b627 --- /dev/null +++ b/dgbuilder/tools/rs @@ -0,0 +1,2 @@ +#replaces / with a . +echo $1|sed -e s%/%.%g diff --git a/dgbuilder/tools/setClasspath b/dgbuilder/tools/setClasspath new file mode 100755 index 00000000..898ef350 --- /dev/null +++ b/dgbuilder/tools/setClasspath @@ -0,0 +1,13 @@ +toolsDir=${PROJECT_HOME}/tools +svcLogicLib=${PROJECT_HOME}/svclogic/lib + +export CLASSPATH= +for i in `find ${svcLogicLib} -name "*.jar" -print` +do +export CLASSPATH=$CLASSPATH:$i +done + +for i in `find ${toolsDir}/tmpws/jars -name "*.jar" -print` +do +export CLASSPATH=$CLASSPATH:$i +done -- cgit 1.2.3-korg