Init dcae.pgaas

Change-Id: Ieef6b600f4cbb0bf4ee3910c1bfc6b36773cd2d2
Signed-off-by: lj1412 <lji@research.att.com>

38 files changed, 2937 insertions, 0 deletions

diff --git a/cdf/src/cdf-prop-value/README.md b/cdf/src/cdf-prop-value/README.md
new file mode 100644
index 0000000..101471c
--- /dev/null
+++ b/cdf/src/cdf-prop-value/README.md
@@ -0,0 +1,53 @@
+org.openecomp.dcae.cdf [^1]
+======================
+
+This repository contails two modules:
+* `cdf-util`: a port of the support functions needed to support CdfPortValue command
+* `cdf-prop-value` : contains only the CdfPortValue command
+
+## Building
+
+To build:
+* `cd cdf-util-build; mvn package`
+
+## Usage
+
+Command: `/opt/cdf/bin/getpropvalue`
+
+`/opt/cdf/bin/getpropvalue [-x] -n property -f property-file`
+	Extract the named value from the given property-file (or full pathname[^2])
+
+`/opt/cdf/bin/getpropvalue -e method [-n property] [-s salt] -v value`
+	Encrypt the given property with the given name and value
+
+`/opt/cdf/bin/getpropvalue -u value`
+	Decrypt the given value, expressed as a triple METHOD:HEXSALT:HEXVAL
+
+`/opt/cdf/bin/setencryptedvalues` (same as `/opt/cdf/bin/getpropvalue -E`)
+	Encrypt all lines that look like ENCRYPTME.METHOD.name=value
+
+## Examples
+
+    # using config files:
+
+    # echo ENCRYPTME.AES.input=bogus | /opt/cdf/bin/setencryptedvalues > testconfig.txt
+    
+    # cat testconfig.txt
+    input.x=AES:353438323235:bf046d8a3e8b12fb678f5dec1e9d5743
+    
+    # /opt/cdf/bin/getpropvalue -x -n input -f /home/ht1659/src/cdf/testconfig.txt
+    bogus
+    
+    # No file:
+    
+	# /opt/cdf/bin/getpropvalue -e AES -v bogus
+    AES:34383638353831:0e699f0f818593e3adbc642efed20341
+    
+    # /opt/cdf/bin/getpropvalue -u AES:323937323833:8d95d8803978c4b13497b394d56a4a9c
+    bogus
+
+
+
+[^1]: Version 1.0, 24 Dec 2015
+
+[^2]: The property-file valued currently requires a rooted (full) pathname.
diff --git a/cdf/src/cdf-prop-value/buildjars/gnu_getopt.jar b/cdf/src/cdf-prop-value/buildjars/gnu_getopt.jar
new file mode 100644
index 0000000..8105152
--- /dev/null
+++ b/cdf/src/cdf-prop-value/buildjars/gnu_getopt.jar
diff --git a/cdf/src/cdf-prop-value/cdf-prop-value/pom.xml b/cdf/src/cdf-prop-value/cdf-prop-value/pom.xml
new file mode 100644
index 0000000..208d5f7
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-prop-value/pom.xml
@@ -0,0 +1,28 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>org.openecomp.dcae.cdf</groupId>
+  <artifactId>cdf-prop-value</artifactId>
+  <packaging>jar</packaging>
+  <version>1.0-SNAPSHOT</version>
+  <name>cdf-prop-value</name>
+  <url>http://maven.apache.org</url>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.openecomp.dcae.cdf</groupId>
+      <artifactId>cdf-util</artifactId>
+      <version>1.0-SNAPSHOT</version>
+    </dependency>
+
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.1</version>
+      <scope>test</scope>
+    </dependency>
+
+  </dependencies>
+
+</project>
diff --git a/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/.gitignore b/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/.gitignore
new file mode 100644
index 0000000..863d673
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/.gitignore
@@ -0,0 +1 @@
+javadoc
diff --git a/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/cdf-prop-value.jar b/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/cdf-prop-value.jar
new file mode 100644
index 0000000..ba5a4a7
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/cdf-prop-value.jar
diff --git a/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/makefile b/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/makefile
new file mode 100644
index 0000000..3591a88
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/makefile
@@ -0,0 +1,29 @@
+go=../../../../buildjars/gnu_getopt.jar
+cu=../../../../cdf-util/src/main/java/cdf-util.jar
+
+.SUFFIXES= .class
+
+JAVA=org/openecomp/dcae/cdf/CdfPropValue.java
+CLASSES=$(JAVA:.java=.class)
+
+all:
+
+build: cdf-prop-value.jar
+
+classes: $(CLASSES)
+
+clean:
+	find . -name '*.class' -exec rm -f {} +
+	rm -rf javadoc
+
+cdf-prop-value.jar: classes
+	rm -f cdf-prop-value.jar
+	jar cvf cdf-prop-value.jar $(CLASSES)
+
+$(CLASSES): $(JAVA)
+	javac -cp $(go):$(cu) $(JAVA)
+
+javadocs:
+	rm -rf javadoc
+	mkdir -p javadoc
+	javadoc -d javadoc -classpath $(go):$(cu) $(JAVA)
diff --git a/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/org/openecomp/dcae/cdf/.gitignore b/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/org/openecomp/dcae/cdf/.gitignore
new file mode 100644
index 0000000..6b468b6
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/org/openecomp/dcae/cdf/.gitignore
@@ -0,0 +1 @@
+*.class
diff --git a/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/org/openecomp/dcae/cdf/CdfPropValue.java b/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/org/openecomp/dcae/cdf/CdfPropValue.java
new file mode 100644
index 0000000..870835a
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-prop-value/src/main/java/org/openecomp/dcae/cdf/CdfPropValue.java
@@ -0,0 +1,86 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf;
+
+import org.openecomp.dcae.cdf.util.config.PropValue;
+import java.util.logging.Logger;
+import org.openecomp.dcae.cdf.util.config.Configuration;
+import java.io.InputStream;
+import java.io.PrintStream;
+
+public class CdfPropValue extends PropValue {
+    public static String getCDFHOME() {
+        String optCdf = System.getProperty("CDF_HOME");
+        if (optCdf == null) optCdf = System.getenv("CDF_HOME");
+        if (optCdf == null) optCdf = "/opt/app/cdf";
+        return optCdf;
+    }
+
+    public static String getGLOBALPROPFILE() {
+        String optCdfCfg = System.getProperty("CDF_CFG");
+        if (optCdfCfg == null) optCdfCfg = System.getenv("CDF_CFG");
+        if (optCdfCfg == null) optCdfCfg = getCDFHOME() + "/lib/cdf.cfg";
+        return optCdfCfg;
+    }
+
+    public static void init() {
+	PropValue.setGlobalPropFile(getGLOBALPROPFILE());
+	PropValue.setEncryptionKeyProperty("Global_Title");
+    }
+    static {
+	init();
+    }
+
+    public static void printEncryptedProperty(String method, String name, String salt, String value, String globalPropFile) {
+	PropValue.printEncryptedProperty(method, name, salt, value, globalPropFile);
+    }
+    public static String generateEncryptedProperty(String method, String salt, String value, String globalPropFile) throws Exception {
+	return PropValue.generateEncryptedProperty(method, salt, value, globalPropFile);
+    }
+    public static String generateEncryptedProperty(String method, String salt, String value, PropValue propValue) throws Exception {
+	return PropValue.generateEncryptedProperty(method, salt, value, propValue);
+    }
+    public static void extractProperty(String f, String name, boolean encrypted) {
+	PropValue.extractProperty(f, name, encrypted);
+    }
+    public static void extractProperty(String f, String name, boolean encrypted, String globalPropFile) {
+	PropValue.extractProperty(f, name, encrypted, globalPropFile);
+    }
+    public static String decryptTriple(String triple, String globalPropFile) {
+	return PropValue.decryptTriple(triple, globalPropFile);
+    }
+    public static String decryptTriple(String triple, PropValue propValue) {
+	return PropValue.decryptTriple(triple, propValue);
+    }
+    public static void encryptInput(InputStream in, PrintStream out) throws Exception {
+	PropValue.encryptInput(in, out);
+    }
+    public static void encryptInput() throws Exception {
+	PropValue.encryptInput();
+    }
+    public static void encryptInput(String globalPropFile, InputStream sysin, PrintStream sysout) throws Exception {
+	PropValue.encryptInput(globalPropFile, sysin, sysout);
+    }
+    public static void main(String args[]) throws Exception {
+	PropValue.main(args);
+    }
+
+
+    public CdfPropValue(Configuration globalConfig, Logger logger) {
+	super(globalConfig, logger);
+    }
+
+}
diff --git a/cdf/src/cdf-prop-value/cdf-prop-value/src/test/java/org/openecomp/dcae/cdf/cdfpropvalue/AppTest.java b/cdf/src/cdf-prop-value/cdf-prop-value/src/test/java/org/openecomp/dcae/cdf/cdfpropvalue/AppTest.java
new file mode 100644
index 0000000..23ae351
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-prop-value/src/test/java/org/openecomp/dcae/cdf/cdfpropvalue/AppTest.java
@@ -0,0 +1,53 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. 
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this code 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.openecomp.dcae.cdf.cdfpropvalue;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest 
+    extends TestCase
+{
+    /**
+     * Create the test case
+     *
+     * @param testName name of the test case
+     */
+    public AppTest( String testName )
+    {
+        super( testName );
+    }
+
+    /**
+     * @return the suite of tests being tested
+     */
+    public static Test suite()
+    {
+        return new TestSuite( AppTest.class );
+    }
+
+    /**
+     * Rigourous Test :-)
+     */
+    public void testApp()
+    {
+        assertTrue( true );
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/pom.xml b/cdf/src/cdf-prop-value/cdf-util/pom.xml
new file mode 100644
index 0000000..3f012fb
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/pom.xml
@@ -0,0 +1,26 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>org.openecomp.dcae.cdf</groupId>
+  <artifactId>cdf-util</artifactId>
+  <packaging>jar</packaging>
+  <version>1.0-SNAPSHOT</version>
+  <name>cdf-util</name>
+  <url>http://maven.apache.org</url>
+
+  <dependencies>
+    <dependency>
+      <groupId>gnu.getopt</groupId>
+      <artifactId>java-getopt</artifactId>
+      <version>1.0.13</version>
+    </dependency>
+
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.1</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/.gitignore b/cdf/src/cdf-prop-value/cdf-util/src/main/java/.gitignore
new file mode 100644
index 0000000..863d673
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/.gitignore
@@ -0,0 +1 @@
+javadoc
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/cdf-util.jar b/cdf/src/cdf-prop-value/cdf-util/src/main/java/cdf-util.jar
new file mode 100644
index 0000000..8c43f9a
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/cdf-util.jar
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/makefile b/cdf/src/cdf-prop-value/cdf-util/src/main/java/makefile
new file mode 100644
index 0000000..af2f0b0
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/makefile
@@ -0,0 +1,47 @@
+
+go=../../../../buildjars/gnu_getopt.jar
+
+.SUFFIXES= .class
+
+JAVA=	org/openecomp/dcae/cdf/util/common/Classify.java \
+	org/openecomp/dcae/cdf/util/common/Tuple3.java \
+	org/openecomp/dcae/cdf/util/common/AsHex.java \
+	org/openecomp/dcae/cdf/util/common/G2CookieGen.java \
+	org/openecomp/dcae/cdf/util/common/Compress.java \
+	org/openecomp/dcae/cdf/util/common/Pair.java \
+	org/openecomp/dcae/cdf/util/common/Tuple4.java \
+	org/openecomp/dcae/cdf/util/common/Hostname.java \
+	org/openecomp/dcae/cdf/util/common/Uid.java \
+	org/openecomp/dcae/cdf/util/common/Tuple2.java \
+	org/openecomp/dcae/cdf/util/common/Pid.java \
+	org/openecomp/dcae/cdf/util/common/Convert.java \
+	org/openecomp/dcae/cdf/util/common/Popen.java \
+	org/openecomp/dcae/cdf/util/config/PropValue.java \
+	org/openecomp/dcae/cdf/util/config/Configuration.java \
+	org/openecomp/dcae/cdf/util/config/EncryptedConfiguration.java \
+	org/openecomp/dcae/cdf/util/config/Configurable.java \
+	org/openecomp/dcae/cdf/util/config/ConfigurationRegistry.java \
+	org/openecomp/dcae/cdf/util/threads/TaskThread.java \
+	org/openecomp/dcae/cdf/util/threads/ThreadCommon.java
+
+CLASSES=$(JAVA:.java=.class)
+
+all:
+
+build: cdf-util.jar
+
+cdf-util.jar: $(CLASSES)
+	rm -f cdf-util.jar
+	jar cvf cdf-util.jar $(CLASSES)
+
+clean: 
+	find . -name '*.class' -exec rm -f {} +
+	rm -rf javadoc
+
+$(CLASSES): $(JAVA)
+	javac -cp $(go) $(JAVA)
+
+javadocs:
+	rm -rf javadoc
+	mkdir -p javadoc
+	javadoc -d javadoc -classpath $(go) $(JAVA)
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/.gitignore b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/.gitignore
new file mode 100644
index 0000000..6b468b6
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/.gitignore
@@ -0,0 +1 @@
+*.class
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/AsHex.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/AsHex.java
new file mode 100644
index 0000000..9fcbdbf
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/AsHex.java
@@ -0,0 +1,116 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+public class AsHex
+{
+    public static String asHex(byte[] data, int offset, int length, String sep) {
+        return asHex(data, offset, length, true);
+    }
+    public static String asHex(byte[] data, String sep) {
+        return asHex(data, 0, data.length, sep);
+    }
+    public static String asHex(byte[] data, int offset, int length) {
+        return asHex(data, offset, length, " ");
+    }
+    public static String asHex(byte[] data) {
+        return asHex(data, 0, data.length);
+    }
+
+    public static String asHex(String data) {
+        return asHex(data.getBytes());
+    }
+
+    static private int asHexBlockLength = 16;
+    public static void setAsHexBlockLength(int n) { asHexBlockLength = n; }
+    public static int getAsHexBlockLength() { return asHexBlockLength; }
+
+    private final static char[] hexdigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+
+    /**
+     * return a byte buf as a hex string
+     */
+    public static String asHex(byte[] buf, int offset, int length, boolean addFinalNL) {
+        StringBuilder ret = new StringBuilder();
+        return asHex(ret, buf, offset, length, addFinalNL).toString();
+    }
+
+    /**
+     * Return a byte buf as hex into the provided StringBuilder.
+     */
+    public static StringBuilder asHex(StringBuilder ret, byte[] buf, int offset, int length, boolean addFinalNL) {
+        final int blockLength = asHexBlockLength;
+        for (int o = 0; o < length; o += blockLength) {
+            int iend = (o + blockLength < length) ? (o + blockLength) : length;
+            int pend = o + blockLength;
+            for (int i = o; i < iend; i++) {
+                int b = (int)(buf[i+offset] & 0xFF);
+                ret.append(hexdigits[b/16]);
+                ret.append(hexdigits[b%16]);
+            }
+            for (int i = iend; i < pend; i++) {
+                ret.append("  ");
+            }
+            ret.append("  ");
+            for (int i = o; i < iend; i++) {
+                byte b = buf[i+offset];
+                int ib = (int)(b & 0xFF);
+                if ((ib >= 0x20) && (ib < 0x7f)) ret.append((char)b);
+                else ret.append('.');
+            }
+            if (iend < length) ret.append('\n');
+        }
+        if (addFinalNL && (length%blockLength != 0)) ret.append('\n');
+        return ret;
+    }
+
+    /**
+     * Return a byte buf as hex with a maximum number of lines.
+     */
+    public static String asHexWithMaxLines(byte[] buf, int offset, int length, int maxLines, boolean addFinalNL) {
+        StringBuilder ret = new StringBuilder();
+        return asHexWithMaxLines(ret, buf, offset, length, maxLines, addFinalNL).toString();
+    }
+
+    /**
+     * Return a byte buf as hex into the provided StringBuilder with a maximum number of lines.
+     */
+    public static StringBuilder asHexWithMaxLines(StringBuilder ret, byte[] buf, int offset, int length, int maxLines, boolean addFinalNL) {
+        int bytesToPrint = length - offset;
+        if (maxLines < 1) maxLines = 1;
+        int maxBytesToPrint = maxLines * asHexBlockLength;
+        if (bytesToPrint <= maxBytesToPrint) {
+            return asHex(ret, buf, offset, length, addFinalNL);
+        } else {
+            if (bytesToPrint > maxBytesToPrint) bytesToPrint = maxBytesToPrint;
+            asHex(ret, buf, offset, offset + bytesToPrint, false);
+            ret.append("  ....");
+            if (addFinalNL) ret.append("\n");
+            return ret;
+            // return asHex(ret, buf, length - halfBytesToPrint, length, addFinalNL);
+        }
+    }
+
+    // Convert a hex string back to a byte array.
+    // This assumes that there is no whitespace within the string.
+    //    public static byte[] fromHex(String hexStr) {
+    //        byte[] bts = new byte[hexStr.length() / 2];
+    //        for (int i = 0; i < bts.length; i++) {
+    //            bts[i] = (byte) Integer.parseInt(hexStr.substring(2*i, 2*i+2), 16);
+    //        }
+    //        return bts;
+    //    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Classify.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Classify.java
new file mode 100644
index 0000000..2334579
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Classify.java
@@ -0,0 +1,109 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+import java.lang.Character;
+
+/**
+ * Classify holds various checking functions.
+ */
+public final class Classify {
+
+    /**
+     * isHex(ch) - is a character a hex value?
+     *
+     * @param ch (char)
+     * @return boolean
+     */
+    public static boolean isHex(char ch) {
+	return (ch >= '0' && ch <= '9') ||
+	       (ch >= 'A' && ch <= 'F') ||
+	       (ch >= 'a' && ch <= 'f');
+    }
+
+    /**
+     * isValidGuid
+     *
+     * @param input (String)
+     * @return boolean
+     */
+
+    public static boolean isValidGuid(String input) {
+        // Checks if the GUID has the following format: "0f114b6f-3f1d-4c8f-a065-2a2ec3d0f522"
+
+        if ( (input == null) || (input.length() != 36)) return false;
+
+        for (int i=0; i < 36; i++) {
+            char c = input.charAt(i);
+            if ( (i==8 || i==13 || i==18 || i==23)) {
+                if (c != '-') return false;
+            }
+            else if (!isHex(c)) return false;
+        }
+        return true;
+    }
+
+
+    /**
+     * isValidClli
+     *
+     * @param input (String)
+     * @return boolean
+     */
+    
+    public static boolean isValidClli(String input) {
+        // Checks if the CLLI only contains letters or digits.
+        
+        if (input == null) return false;
+	int len = input.length();
+        if (len == 0) return false;
+
+        for (int i=0; i < len; i++) {
+            char c = input.charAt(i);
+            if (!Character.isLetterOrDigit(c)) return false;
+        }
+        return true;
+    }
+
+
+    /**
+     * isValidCanonicalIpv4Address
+     *
+     * @param ipAddress (String)
+     * @return boolean
+     */
+    
+    public static boolean isValidCanonicalIpv4Address(String ipAddress) {
+
+        String[] parts = ipAddress.split( "\\." );
+
+        if ( parts.length != 4 ) {
+            return false;
+        }
+        for ( String s : parts ) {
+            try {
+                int i = Integer.parseInt( s );
+                if ( (i < 0) || (i > 255) ) {
+                    return false;
+                }
+            } catch (Exception ex) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Compress.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Compress.java
new file mode 100644
index 0000000..add6eca
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Compress.java
@@ -0,0 +1,131 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+import java.util.zip.GZIPOutputStream;
+import java.util.zip.ZipOutputStream;
+import java.util.zip.ZipEntry;
+// import java.io.InputStream;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.File;
+import java.io.IOException;
+
+public class Compress {
+
+    /**
+     * Compress a file with the gzip algorithm, sending output to outFilename.
+     * Based on code at http://www.java-tips.org/java-se-tips/java.util.zip/how-to-compress-a-file-in-the-gip-format.html.
+     */
+    public static void gzip(String inFilename, String outFilename) throws IOException {
+	String tmpFilename = outFilename + ".tmp";
+	try {
+	    // Create the GZIP output stream
+	    GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream(tmpFilename));
+
+	    // Open the input file
+	    FileInputStream in = new FileInputStream(inFilename);
+
+	    // Transfer bytes from the input file to the GZIP output stream
+	    byte[] buf = new byte[4096];
+	    int len;
+	    while ((len = in.read(buf)) > 0) {
+		out.write(buf, 0, len);
+	    }
+	    in.close();
+
+	    // Complete the GZIP file
+	    out.finish();
+	    out.close();
+	    
+	    // rename .gz.tmp to .gz
+	    File target = new File(outFilename);
+	    if (target.exists()) target.delete();
+	    File file = new File(tmpFilename);
+	    boolean result = file.renameTo(target);
+	    if (!result) throw new IOException("Cannot rename " + tmpFilename + " to " + outFilename);
+	} catch (IOException e) {
+	    // If we can't write the gzip file, remove it and pass on the exception.
+	    File f = new File(outFilename);
+	    f.delete();
+	    throw e;
+	}
+    }
+
+    /**
+     * Compress a file with the gzip algorithm, sending output to filename+".gz".
+     */
+    public static void gzip(String filename) throws IOException {
+        gzip(filename, filename + ".gz");
+    }
+
+    /**
+     * Compress a file with the zip algorithm, sending output to outFilename
+     * Based on code at http://www.java-tips.org/java-se-tips/java.util.zip/how-to-compress-a-file-in-the-gip-format.html.
+     */
+    public static void zip(String inFilename, String outFilename) throws IOException {
+	String tmpFilename = outFilename + ".tmp";
+	try {
+	    // Create the ZIP output stream
+	    ZipOutputStream out = new ZipOutputStream(new FileOutputStream(tmpFilename));
+	    ZipEntry zipEntry = new ZipEntry(inFilename);
+	    out.putNextEntry(zipEntry);
+
+	    // Open the input file
+	    FileInputStream in = new FileInputStream(inFilename);
+
+	    // Transfer bytes from the input file to the ZIP output stream
+	    byte[] buf = new byte[4096];
+	    int len;
+	    while ((len = in.read(buf)) > 0) {
+		out.write(buf, 0, len);
+	    }
+	    in.close();
+
+	    // Complete the ZIP file
+	    out.finish();
+	    out.close();
+	    
+	    // rename .zip.tmp to .zip
+	    File target = new File(outFilename);
+	    if (target.exists()) target.delete();
+	    File file = new File(tmpFilename);
+	    boolean result = file.renameTo(target);
+	    if (!result) throw new IOException("Cannot rename " + tmpFilename + " to " + outFilename);
+	} catch (IOException e) {
+	    // If we can't write the zip file, remove it and pass on the exception.
+	    File f = new File(outFilename);
+	    f.delete();
+	    throw e;
+	}
+    }
+
+    /**
+     * Compress a file with the gzip algorithm, sending output to filename+".zip".
+     */
+    public static void zip(String filename) throws IOException {
+        zip(filename, filename + ".zip");
+    }
+
+    public static void main(String args[]) throws Exception {
+	if (args.length == 1) {
+	    gzip(args[0]);
+	    zip(args[0]);
+	} else {
+	    System.err.println("Usage: java Compress filename");
+	}
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Convert.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Convert.java
new file mode 100644
index 0000000..9deba10
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Convert.java
@@ -0,0 +1,97 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+import java.lang.Character;
+
+/**
+ * Covert holds various conversion functions.
+ */
+public final class Convert {
+
+    private static final char[] HEX_CHARS = "0123456789abcdef".toCharArray();
+
+    /**
+     * toHexString(String) - convert a string into its hex equivalent
+     */
+    public static String toHexString(String buf) {
+	if (buf == null) return "";
+	return toHexString(buf.getBytes());
+    }
+
+    /**
+     * toHexString(byte[]) - convert a byte-string into its hex equivalent
+     */
+    public static String toHexString(byte[] buf) {
+	if (buf == null) return "";
+	char[] chars = new char[2 * buf.length];
+	for (int i = 0; i < buf.length; ++i) {
+	    chars[2 * i] = HEX_CHARS[(buf[i] & 0xF0) >>> 4];
+	    chars[2 * i + 1] = HEX_CHARS[buf[i] & 0x0F];
+	}
+	return new String(chars);
+    }
+
+    // alternate implementation that's slightly slower
+    // protected static final byte[] Hexhars = {
+    //	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+    // };
+    // public static String encode(byte[] b) {
+    //	StringBuilder s = new StringBuilder(2 * b.length);
+    //	for (int i = 0; i < b.length; i++) {
+    //	    int v = b[i] & 0xff;
+    //	    s.append((char)Hexhars[v >> 4]);
+    //	    s.append((char)Hexhars[v & 0xf]);
+    //	}
+    //	return s.toString();
+    // }
+
+    /**
+     * Convert a hex string to its equivalent value.
+     */
+    public static String stringFromHex(String hexString) throws Exception {
+	if (hexString == null) return "";
+	return stringFromHex(hexString.toCharArray());
+    }
+
+    public static String stringFromHex(char[] hexCharArray) throws Exception {
+	if (hexCharArray == null) return "";
+	return new String(bytesFromHex(hexCharArray));
+    }
+
+    public static byte[] bytesFromHex(String hexString) throws Exception {
+	if (hexString == null) return new byte[0];
+        return bytesFromHex(hexString.toCharArray());
+    }
+
+    public static byte[] bytesFromHex(char[] hexCharArray) throws Exception {
+	if (hexCharArray == null) return new byte[0];
+	int len = hexCharArray.length;
+	if ((len % 2) != 0) throw new Exception("Odd number of characters: '" + hexCharArray + "'");
+	byte [] txtInByte = new byte [len / 2];
+	int j = 0;
+	for (int i = 0; i < len; i += 2) {
+	    txtInByte[j++] = (byte)(((fromHexDigit(hexCharArray[i], i) << 4) | fromHexDigit(hexCharArray[i+1], i)) & 0xFF);
+	}
+	return txtInByte;
+    }
+
+    protected final static int fromHexDigit(char ch, int index) throws Exception {
+	int digit = Character.digit(ch, 16);
+	if (digit == -1) throw new Exception("Illegal hex character '" + ch + "' at index " + index);
+	return digit;
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/G2CookieGen.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/G2CookieGen.java
new file mode 100644
index 0000000..aeed01b
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/G2CookieGen.java
@@ -0,0 +1,209 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+import javax.crypto.Cipher;
+// import javax.crypto.SecretKey;
+// import javax.crypto.KeyGenerator;
+// import javax.crypto.spec.IvParameterSpec;
+import java.security.Key;
+// import java.security.NoSuchAlgorithmException;
+// import java.security.SecureRandom;
+// import javax.crypto.SecretKey;
+// import sun.misc.*;
+import java.util.*;
+
+public class G2CookieGen
+{
+  private Cipher cipher;
+  private Key key = null;
+
+  private static String alg = "DES";
+  private static String desecb = "DES/ECB/PKCS5Padding";
+
+  public static String G2_CLIENT_MEC_ID_1 = "MEC0001";
+  private static String G2_CLIENT_MEC_ID_2 = "MEC0002";
+  public static String G2_ENCRYPT_KEY = "secretK9";
+  public static String G2_EPOCH_TM_STR = null;
+
+
+  private static long G2_TM_DELTA_IN_MILLISECONDS = 10*60*1000;
+  
+  class G2WSSKey implements Key 
+  {
+    private final byte[] keyBytes;
+    private final String alg;
+  
+    G2WSSKey(String algorithm, byte[] keyBytes) 
+    {
+      this.alg  = algorithm;
+      this.keyBytes = keyBytes;
+    }
+  
+    public String getAlgorithm() 
+    {
+      return alg;  
+    }
+    public String getFormat()    
+    {
+      return "RAW"; 
+    }
+    public byte[] getEncoded()   
+    {
+      return (byte[])keyBytes.clone(); 
+    }
+  }
+  
+
+  public G2CookieGen() {
+    try {
+      cipher = Cipher.getInstance(desecb);
+    } catch (Throwable t) {
+      System.err.println(t.toString());
+      return;
+    }
+  }
+
+
+  public static String getClient1MacId() {
+    return G2_CLIENT_MEC_ID_1;
+  }
+
+  public static String getClient2MacId() {
+    return G2_CLIENT_MEC_ID_2;
+  }
+
+  public static String toHexStringFromByteArray(byte[] bytes)
+  {
+    StringBuilder retString = new StringBuilder();
+    for (int i = 0; i < bytes.length; ++i) {
+      retString.append(Integer.toHexString(0x0100 + (bytes[i] & 0x00FF)).substring(1));
+    }
+    return retString.toString();
+  }
+
+  public static byte[] toByteArrayFromHexString(String hexStr)
+  {
+    byte[] bts = new byte[hexStr.length() / 2];
+    for (int i = 0; i < bts.length; i++) {
+      bts[i] = (byte) Integer.parseInt(hexStr.substring(2*i, 2*i+2), 16);
+    }
+    return bts;
+  }
+
+  public byte[] encryptData(String sData)
+  {
+    try {
+      byte[] data = sData.getBytes();
+      //System.out.println("Original data : " + new String(data));
+	  if (key == null) setKey(G2_ENCRYPT_KEY);
+      cipher.init(Cipher.ENCRYPT_MODE, key);
+      byte[] result = cipher.doFinal(data);
+      return result;
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    return null;
+  }
+
+  public String decryptData(byte[] sData)
+  {
+    try {
+      cipher.init(Cipher.DECRYPT_MODE, key);
+      byte[] result = cipher.doFinal(sData);
+      return new String(result);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    return null;
+  }
+
+  public String constructCookie(String mechId) {
+	  return mechId + ":" + System.currentTimeMillis();
+  }
+
+  public void setKey(String g2EncryptKey)	{
+      key =  new G2WSSKey(this.alg, g2EncryptKey.getBytes());
+  }
+
+  public String getEncryptedCookie(String mechId, String g2EncryptKey) {
+      setKey(g2EncryptKey);
+	  String tmp = constructCookie(mechId);
+	  byte[] byteArray = this.encryptData(tmp);
+      return this.toHexStringFromByteArray(byteArray);
+  }
+
+  public long getTimeMillisFromCookie(String cookie) {
+    StringTokenizer tkn = new StringTokenizer(cookie,":");
+    String tmStr = null;
+    while (tkn.hasMoreTokens()) {
+      tmStr = tkn.nextToken();
+    }
+    Long tmLong = new Long(tmStr);
+    return tmLong.longValue();
+  }
+
+  public boolean isValid(long tm) {
+    long ctm = System.currentTimeMillis();
+System.out.println("Current Time="+ctm);
+System.out.println("G2_TM_DELTA_IN_MILLISECONDS="+G2_TM_DELTA_IN_MILLISECONDS);
+    if ( Math.abs(ctm - tm) <= G2_TM_DELTA_IN_MILLISECONDS ) {
+      return true;
+    }
+    return false;
+  }
+
+
+  public static void main(String argv[]) {
+    try {
+      if (argv.length > 0) {
+System.out.println("using Client MACID="+argv[0]);
+         G2_CLIENT_MEC_ID_1 = argv[0];
+       
+      }
+
+      if (argv.length > 1) {
+         if (argv[1].length() == 8) {
+System.out.println("using Key="+argv[1]);
+            G2_ENCRYPT_KEY = argv[1];
+         }
+      }
+
+      if (argv.length > 2) {
+System.out.println("using Epoch Time (in seconds) ="+argv[2]);
+            G2_EPOCH_TM_STR = argv[2];
+      }
+
+
+      G2CookieGen wssc = new G2CookieGen();
+
+// System.out.println("tz_diff="+G2_CLIENT_TM_ZONE_TO_PDT_IN_MILLISECONDS);
+System.out.println("macid="+G2_CLIENT_MEC_ID_1);
+
+      String cookie = wssc.constructCookie(G2_EPOCH_TM_STR);
+System.out.println("original cookie="+cookie);
+
+      byte[] byteArrary = wssc.encryptData(cookie);
+      String hexString = wssc.toHexStringFromByteArray(byteArrary);
+System.out.println("encrypted cookie="+hexString);
+      System.exit(0);
+
+    } catch (Exception e) {
+      System.err.println("Error: " + e);
+      System.exit(1);
+    }
+  }  /* main */
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Hostname.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Hostname.java
new file mode 100644
index 0000000..56f312b
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Hostname.java
@@ -0,0 +1,108 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+import java.net.InetAddress;
+
+public class Hostname {
+
+    /** 
+     * Hostname FQDN
+     */
+    public static String getHostName() {
+        return getHostName("unknown.unknown");
+    }
+
+    /** 
+     * Hostname FQDN
+     */
+    public static String getHostName(String def) {
+        return (uname == null) ? def : hostName;
+    }
+
+    /** 
+     * uname, the 1st portion of the hostname FQDN
+     */
+    public static String getUname() {
+        return getUname("unknown");
+    }
+
+    /** 
+     * uname, the 1st portion of the hostname FQDN
+     */
+    public static String getUname(String def) {
+        return (uname == null) ? def : uname;
+    }
+
+    /**
+     *	Get an IP address for this machine
+     */
+    public static String getLocalIP() {
+	return defaultLocalIP;
+    }
+    /**
+     *	Get an IP address for this machine
+     */
+    public static String getLocalIPinHex() {
+	return defaultLocalIPinHex;
+    }
+    /**
+     *	Get a host name for this machine
+     */
+    public static String getCanonicalHostName() {
+	return defaultCanonicalHostName;
+    }
+
+    /**
+     *	Value returned by getLocalIP() method
+     */
+    private static String	defaultLocalIP;
+    private static String	defaultLocalIPinHex;
+    private static String	defaultCanonicalHostName;
+    private static String hostName = null;	// Hostname FQDN
+    private static String uname = null;		// Hostname 1st part
+
+    static {
+	try {
+	    InetAddress ia = InetAddress.getLocalHost();
+	    defaultLocalIP = ia.getHostAddress();
+	    byte b[] = ia.getAddress();
+	    defaultLocalIPinHex = Convert.toHexString(b);
+	    defaultCanonicalHostName = ia.getCanonicalHostName();
+	} catch (Exception e) {
+	    defaultLocalIP = "127.0.0.1";
+	    defaultLocalIPinHex = "7F000001";
+	    defaultCanonicalHostName = "localhost";
+	}
+
+      try {
+         hostName = InetAddress.getLocalHost().getHostName();
+	 String hostNameParts[] = hostName.split("\\.");
+	 uname = hostNameParts[0];
+      } catch (Exception ex) {
+      }
+      int dotInHostname = hostName.indexOf('.');
+      if (dotInHostname > -1) hostName = hostName.substring(0, dotInHostname);
+    }
+
+    public static void main(String args[]) {
+	System.out.println("getHostName() = '" + getHostName() + "'");
+	System.out.println("getUname() = '" + getUname() + "'");
+	System.out.println("getLocalIP() = '" + getLocalIP() + "'");
+	System.out.println("getLocalIPinHex() = '" + getLocalIPinHex() + "'");
+	System.out.println("getCanonicalHostName() = '" + getCanonicalHostName() + "'");
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Pair.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Pair.java
new file mode 100644
index 0000000..524aa6b
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Pair.java
@@ -0,0 +1,40 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+public final class Pair<L,R> {
+    public final L left;
+    public final R right;
+    public Pair(L l, R r) { left = l; right = r; }
+
+    @Override
+    public boolean equals(Object obj) {
+	Pair<L,R> o = (Pair<L,R>)obj;
+	return left.equals(o.left) && right.equals(o.right);
+    }
+    @Override
+    public String toString() {
+	return "(" + left + "," + right + ")";
+    }
+    @Override
+    public int hashCode() {
+	return left.hashCode() + right.hashCode();
+    }
+
+    public static <L,R> Pair<L,R> of(L l, R r) {
+	return new Pair<L,R>(l, r);
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Pid.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Pid.java
new file mode 100644
index 0000000..1730509
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Pid.java
@@ -0,0 +1,37 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+import java.io.File;
+
+public class Pid {
+    /**
+     * Return the pid.
+     */
+    public static int getPid() { return pid; }
+    public static String getPidStr() { return pidStr; }
+
+    private static int pid;
+    private static String pidStr;
+    static {
+	try {
+	    pid = Integer.parseInt( ( new File("/proc/self")).getCanonicalFile().getName() );
+	    pidStr = Integer.toString(pid);
+	} catch (java.io.IOException e) {
+	    pid = -1;
+	    pidStr = "-1";
+	}
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Popen.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Popen.java
new file mode 100644
index 0000000..6d5e8fb
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Popen.java
@@ -0,0 +1,84 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class Popen {
+    public static class Results {
+	public final String stdout, stderr;
+	public final int exitValue;
+	public Results(String so, String se, int e) {
+	    stdout = so; stderr = se; exitValue = e;
+	}
+    }
+
+    public static Results popen(String cmd) throws java.io.IOException, java.lang.InterruptedException {
+	return popen(cmd, null);
+    }
+
+    public static Results popen(String cmd, String stdin) throws java.io.IOException, java.lang.InterruptedException {
+	Process process = Runtime.getRuntime().exec(cmd);
+	return proc(process, stdin);
+    }
+
+    public static Results popen(String[] args) throws java.io.IOException, java.lang.InterruptedException {
+	return popen(args, null);
+    }
+
+    public static Results popen(String[] args, String stdin) throws java.io.IOException, java.lang.InterruptedException {
+	Process process = Runtime.getRuntime().exec(args);
+	return proc(process, stdin);
+    }
+
+    private static Results proc(Process process, String stdin) throws java.io.IOException, java.lang.InterruptedException {
+	OutputStream pinput = process.getOutputStream();
+	InputStream poutput = process.getInputStream();
+	InputStream perror = process.getErrorStream();
+
+	if (stdin != null)
+	    pinput.write(stdin.getBytes());
+	pinput.close();
+
+	String stdout = captureStream(poutput);
+	poutput.close();
+	String stderr = captureStream(perror);
+	perror.close();
+	process.waitFor();
+	//	System.out.println("stdin=\nnvvvvvvvvvvvvvvvv\n");
+	//	System.out.println(stdin);
+	//	System.out.println("^^^^^^^^^^^^^^^^");
+	//	System.out.println("stdout=\nvvvvvvvvvvvvvvvv\n");
+	//	System.out.println(stdout);
+	//	System.out.println("^^^^^^^^^^^^^^^^");
+	//	System.out.println("stderr=\nvvvvvvvvvvvvvvvv\n");
+	//	System.out.println(stderr);
+	//	System.out.println("^^^^^^^^^^^^^^^^");
+	return new Results(stdout, stderr, process.exitValue());
+    }
+
+    private static String captureStream(InputStream inp) throws java.io.IOException {
+	byte[] buf = new byte[8192];
+	StringBuffer out = new StringBuffer();
+	int b;
+	while ((b = inp.read(buf)) > 0) {
+	    out.append(new String(buf, 0, b));
+	}
+	return out.toString();
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Tuple2.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Tuple2.java
new file mode 100644
index 0000000..dd48ea8
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Tuple2.java
@@ -0,0 +1,25 @@
+// -*- indent-tabs-mode: nil -*-
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+public class Tuple2<T1,T2> {
+    public Tuple2(T1 n1, T2 n2) {
+	t1 = n1; t2 = n2;
+    }
+    public final T1 t1;
+    public final T2 t2;
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Tuple3.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Tuple3.java
new file mode 100644
index 0000000..1293059
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Tuple3.java
@@ -0,0 +1,29 @@
+// -*- indent-tabs-mode: nil -*-
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+public class Tuple3<T1,T2,T3> extends Tuple2<T1,T2> {
+    public Tuple3(T1 n1, T2 n2, T3 n3) {
+	super(n1, n2);
+	t3 = n3;
+    }
+    public Tuple3(Tuple3<T1,T2,T3> t) {
+        super(t.t1, t.t2);
+        t3 = t.t3;
+    }
+    public final T3 t3;
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Tuple4.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Tuple4.java
new file mode 100644
index 0000000..a2c10e8
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Tuple4.java
@@ -0,0 +1,29 @@
+// -*- indent-tabs-mode: nil -*-
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+
+public class Tuple4<T1,T2,T3,T4> extends Tuple3<T1,T2,T3> {
+    public Tuple4(T1 n1, T2 n2, T3 n3, T4 n4) {
+	super(n1, n2, n3);
+	t4 = n4;
+    }
+    public Tuple4(Tuple4<T1,T2,T3,T4> t) {
+        super(t.t1, t.t2, t.t3);
+        t4 = t.t4;
+    }
+    public final T4 t4;
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Uid.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Uid.java
new file mode 100644
index 0000000..6b2219f
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/common/Uid.java
@@ -0,0 +1,69 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.common;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import org.openecomp.dcae.cdf.util.common.Popen;
+
+public class Uid {
+    /**
+     * Return the uid.
+     */
+    public static int getUid() { return uid; }
+    public static String getUidStr() { return uidStr; }
+
+    private static int uid = -1;
+    private static String uidStr = "";
+    static {
+	try {
+	    uid = getUidFromProcSelfStatus();
+	    if (uid == -1) uid = getUidFromIdU();
+	    uidStr = Integer.toString(uid);
+	} catch (java.io.IOException e) {
+	    uid = -1;
+	    uidStr = "-1";
+	    System.err.println("Exception: " + e);
+	} catch (Exception e) {
+	    System.err.println("Exception: " + e);
+	}
+	
+    }
+
+    private static int getUidFromProcSelfStatus() throws java.io.IOException {
+	int uid = -1;
+	if (true) return -1;
+	BufferedReader br = new BufferedReader(new FileReader(new File("/proc/self/status")));
+	String thisLine = null;
+	while ((thisLine = br.readLine()) != null) {
+	    if (thisLine.startsWith("Uid:")) {
+		String[] uids = thisLine.split("[: \t]+");
+		if (uids.length > 1) {
+		    uid = Integer.parseInt(uids[1]);
+		    break;
+		}
+	    }
+	}
+	br.close();
+	return uid;
+    }
+
+    private static int getUidFromIdU() throws java.io.IOException, java.lang.InterruptedException {
+	Popen.Results results = Popen.popen("/usr/bin/id -u");
+	uid = Integer.parseInt(results.stdout.trim());
+	return uid;
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/.gitignore b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/.gitignore
new file mode 100644
index 0000000..6b468b6
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/.gitignore
@@ -0,0 +1 @@
+*.class
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/Configurable.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/Configurable.java
new file mode 100644
index 0000000..39e78ca
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/Configurable.java
@@ -0,0 +1,28 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.config;
+
+/**
+ *	The interface for an object that wants to be notified when the
+ *	configuration files have changed (so it can re-configure itself)
+ */
+
+public interface Configurable	{
+	/**
+	 *	Configuration files have changed.
+	 */
+	public void reConfigure();
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/Configuration.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/Configuration.java
new file mode 100644
index 0000000..54ebf47
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/Configuration.java
@@ -0,0 +1,579 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.config;
+
+import java.io.*;
+import java.util.*;
+import java.net.*;
+import java.util.logging.*;
+import org.openecomp.dcae.cdf.util.common.*;
+import org.openecomp.dcae.cdf.util.threads.*;
+
+/**
+ *	Class to monitor configuration parameters and notify
+ *	other objects when they change
+ */
+
+public class Configuration extends Thread implements Configurable {
+	/**
+	 *	Time between checks of config file in milliseconds
+	 */
+	private static int		INTERVAL = 30000;
+	private int			interval = INTERVAL;
+	/**
+	 *	Minimum age of config file before loading it in milliseconds
+	 */
+	private static final int	MINAGE = 30000;
+	private int			minage = MINAGE;
+	/**
+	 *	Value returned by getInstance() method
+	 */
+	private static Configuration	defaultInstance = new Configuration();
+	/**
+	 *	Value returned by getLocalIP() method
+	 */
+	private static String	defaultLocalIP;
+	private static String	defaultLocalIPinHex;
+	private static String	defaultCanonicalHostName;
+	static {
+		try {
+			InetAddress ia = InetAddress.getLocalHost();
+			defaultLocalIP = ia.getHostAddress();
+			byte b[] = ia.getAddress();
+			defaultLocalIPinHex = Convert.toHexString(b);
+			defaultCanonicalHostName = ia.getCanonicalHostName();
+		} catch (Exception e) {
+			defaultLocalIP = "127.0.0.1";
+			defaultLocalIPinHex = "7F000001";
+			defaultCanonicalHostName = "localhost";
+		}
+	}
+	/**
+	 *	Get an IP address for this machine
+	 */
+	public static String getLocalIP() {
+		return defaultLocalIP;
+	}
+	/**
+	 *	Get an IP address for this machine
+	 */
+	public static String getLocalIPinHex() {
+		return defaultLocalIPinHex;
+	}
+	/**
+	 *	Get a host name for this machine
+	 */
+	public static String getCanonicalHostName() {
+		return defaultCanonicalHostName;
+	}
+	/**
+	 *	Get a default global instance
+	 */
+	public static Configuration getInstance() {
+		return defaultInstance;
+	}
+	/**
+	 *	The current configuration
+	 */
+	private ResourceBundle	config;
+	/**
+	 *	Where to log when things go wrong
+	 */
+    private static Logger	logger = Logger.getLogger(Configuration.class.getName());
+	/**
+	 *	The config file to read
+	 */
+	private File	file;
+	/**
+	 *	The name of the config to read, when overriding the file.
+	 */
+	private String	filename;
+	/**
+	 *	The last modified date of the config file
+	 */
+	private long	curdate;
+	/**
+	 *	Should we stop scanning for config file updates?
+	 */
+	private boolean closed;
+	static boolean closeAll = false;
+	/**
+	 *	Have we started scanning for config file updates?
+	 */
+	private boolean initialized;
+	/**
+	 *	The name of the background thread monitoring the file.
+	 */
+	private static String monitorThreadName = "Configuration Monitor";
+	/**
+	 *	How we keep track of registered Configurables.
+	 */
+	private ConfigurationRegistry configurationRegistry = new ConfigurationRegistry();
+	/**
+	 *	included file.
+	 */
+	private Configuration subConfig = null;
+	private String subFile = null;
+
+	public void reConfigure() {
+		configurationRegistry.reConfigureAll(logger);
+	}
+
+	/**
+	 *	Create an instance using the default configuration file
+	 *	"configfile.properties" from the class path
+	 */
+	public Configuration() {
+		// logger.fine("Configuration()");
+	}
+	/**
+	 *	Create an instance using a configuration file
+	 *	"FILENAME.properties" from the class path
+	 */
+	public Configuration(String filename) {
+		// logger.fine("Configuration(" + filename + ")");
+		this.filename = filename;
+	}
+	/**
+	 *	Create an instance using a specific configuration file
+	 */
+	public Configuration(File file) {
+		this.file = file;
+		// logger.fine("Configuration(File)");
+	}
+
+	/**
+	 *	Change the configuration file to use
+	 */
+	public void setConfig(File file) {
+		this.file = file;
+		curdate = 0;
+		interrupt();
+	}
+	/**
+	 * Reset the interval used for rechecking the file.
+	 * @param interval
+	 */
+	public synchronized void setInterval(int interval) {
+		this.interval = interval;
+	}
+	/**
+	 * Reset the default interval used for rechecking the file.
+	 * @param interval
+	 */
+	public synchronized void setDefaultInterval(int interval) {
+		this.INTERVAL = interval;
+	}
+	/**
+	 * Reset the minimum age the file must be before being reread.
+	 * This is used to prevent reading the file while it is being written, say by vi.
+	 * @param minage
+	 */
+	public synchronized void setMinage(int minage) {
+		this.minage = minage;
+	}
+	/**
+	 *	Stop checking for config changes
+	 */
+	public void close() {
+		checkinit();
+		closed = true;
+		if (Thread.currentThread() == this) {
+			return;
+		}
+		interrupt();
+		try {
+			join();
+		} catch (Exception e) {
+		}
+	}
+	/**
+	 *	Check the config file to see if it has changed
+	 */
+	private synchronized void check() {
+		long now = System.currentTimeMillis();
+		if (logger.isLoggable(Level.FINE)) logger.fine("check(): now=" + Long.toString(now));
+		try {
+			long ndate = file.lastModified();
+			if (logger.isLoggable(Level.FINE)) logger.fine("file=" + file + ", ndate=" + Long.toString(ndate) + ", curdate=" + Long.toString(curdate,10));
+			if (ndate == curdate || (now < ndate + minage && curdate != 0)) {
+				return;
+			}
+			if (logger.isLoggable(Level.FINE)) logger.fine("reloading file=" + file);
+			FileInputStream in = new FileInputStream(file);
+			config = new PropertyResourceBundle(in);
+			in.close();
+			try {
+			    String inc = config.getString("include");
+			    if ((inc != null) && !inc.equals("")) {
+				subFile = inc;
+				subConfig = new Configuration(subFile);
+				subConfig.registerConfigurable(this);
+			    }
+			} catch (Exception e) {
+			}
+
+			curdate = ndate;
+			configurationRegistry.reConfigureAll(logger);
+			// logger.info("CNFG0006: Configuration '" + file + "' reloaded");
+		} catch (Exception e) {
+		    logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0004: Configuration file '" + file + "' inaccessible", e);
+		}
+	}
+	/**
+	 *	Make sure we're initialized and read the config file
+	 *	if necessary
+	 */
+	public void checkinit() {
+		// System.out.println("checkinit()");
+		if (initialized) {
+			return;
+		}
+		initialized = true;
+		try {
+			if (file == null) {
+				if (filename == null)
+					filename = System.getProperty("configfile", "configfile");
+				// logger.info("DAIS0073 0.8.73 >>> filename=" + filename);
+				if (filename.charAt(0) == '/') {
+				    // logger.info("DAIS0073 0.8.73 filename has leading slash: " + filename);
+				    file = new File(filename);
+				} else {
+				    URI uri = getClass().getClassLoader().getResource(filename + ".properties").toURI();
+				    // logger.info("DAIS0073 0.8.73 uri=" + uri.toString());
+				    file = new File(uri);
+				}
+			}
+		} catch (Exception e) {
+		    logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0003: Cannot find configuration file '" + filename + "'", e);
+		}
+		check();
+		setDaemon(true);
+		setName(monitorThreadName);
+		start();
+	}
+	/**
+	 *	Check the config file to see if it has changed
+	 */
+	public void run() {
+		if (logger.isLoggable(Level.FINE)) logger.fine("Configuration::run()");
+		while (!closed && !closeAll) {
+			try {
+				if (logger.isLoggable(Level.FINE)) logger.fine("sleeping " + Integer.toString(interval) + ", id=" + Long.toString(Thread.currentThread().getId()) + ", file=" + filename);
+				Thread.sleep(interval);
+			} catch (Exception e) {
+			}
+			if (logger.isLoggable(Level.FINE)) {
+			    Thread currentThread = Thread.currentThread();
+			    logger.fine("checking id=" + Long.toString((currentThread != null) ? currentThread.getId() : -1) + ", file=" + filename);
+			}
+			check();
+		}
+	}
+
+	public static void wakeAllThreads() {
+		try {
+			Thread[] threads = ThreadCommon.getAllThreads( monitorThreadName );
+			for ( Thread thread : threads )
+				thread.interrupt();
+		} catch (Exception e) {
+		}
+	}
+
+	public static void closeAllThreads() {
+		closeAll = true;
+		wakeAllThreads();
+	}
+
+	/**
+	 *	Forward this Configurable to the ConfigurationRegistry to be registered.
+	 */
+	public void registerConfigurable(Configurable element) {
+	    configurationRegistry.registerConfigurable(element);
+	}
+	/**
+	 *	Forward this Configurable to the ConfigurationRegistry to be deRegistered.
+	 */
+	public void deRegisterConfigurable(Configurable element) {
+	    configurationRegistry.deRegisterConfigurable(element);
+	}
+
+	/**
+	 *	Get a configuration parameter as a String.
+	 *	If undefined, return null and log an error.
+	 *	@return String
+	 */
+	public String getString(String name) {
+		return getString(name, null, true);
+	}
+	/**
+	 *	Get a configuration parameter as a String.
+	 *	If undefined, return the specified default value.
+	 *	@return String
+	 */
+	public String getString(String name, String deflt) {
+		return getString(name, deflt, false);
+	}
+
+	public static String trimQuotes(String str) {
+	    if (str == null) return null;
+	    str = str.trim();
+	    int len = str.length();
+	    if (len < 2) return str;
+	    char startChar = str.charAt(0);
+	    char endChar = str.charAt(len-1);
+	    boolean startDoubleQuote = startChar == '"';
+	    boolean startSingleQuote = startChar == '\'';
+	    boolean endDoubleQuote = endChar == '"';
+	    boolean endSingleQuote = endChar == '\'';
+	    if ((startDoubleQuote && endDoubleQuote) ||
+		(startSingleQuote && endSingleQuote)) {
+		return str.substring(1, len-1);
+	    } else {
+		return str;
+	    }
+	}
+
+	/**
+	 *	Get a configuration parameter as a String.
+	 *	If undefined, return the specified default value.
+	 *	If complaining, log an error.
+	 *	@return String
+	 */
+	public String getString(String name, String deflt, boolean complain) {
+		checkinit();
+		try {
+		    return trimQuotes(config.getString(name));
+		} catch (Exception e) {
+			if (subConfig != null) {
+				try {
+					return subConfig.getString(name, deflt, complain);
+				} catch (Exception e2) {
+				}
+			}
+			if (complain)
+			    logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0001: '" + filename + "': Configuration property " + name + " must be defined", e);
+			return deflt;
+		}
+	}
+
+	/**
+	 *	Get a configuration parameter as a String encoded using URL % escapes.
+	 *	If undefined, return null and log an error.
+	 *	@return String
+	 */
+	public String getDecodedString(String name) {
+		return getDecodedString(name, null, true);
+	}
+	/**
+	 *	Get a configuration parameter as a String encoded using URL % escapes.
+	 *	If undefined, return the specified default value.
+	 *	@return String
+	 */
+	public String getDecodedString(String name, String deflt) {
+		return getDecodedString(name, deflt, false);
+	}
+	/**
+	 *	Get a configuration parameter as a String encoded using URL % escapes.
+	 *	If undefined, return the specified default value.
+	 *	If complaining, log an error.
+	 *	@return String
+	 */
+	public String getDecodedString(String name, String deflt, boolean complain) {
+		checkinit();
+		try {
+			return URLDecoder.decode(config.getString(name), "UTF-8");
+		} catch (UnsupportedEncodingException e) {
+		    logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0007: UTF-8 is not recognized as a character set encoding", e);
+			return deflt;
+		} catch (Exception e) {
+			if (complain)
+			    logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0001: '" + filename + "': Configuration property " + name + " must be defined", e);
+			return deflt;
+		}
+	}
+
+	/**
+	 *	Get a configuration parameter as a String[].
+	 *	If undefined, return null and log an error.
+	 *	@return String[]
+	 */
+	public String[] getStrings(String name) {
+		return getStrings(name, null, "[ \t,]+", true);
+	}
+	/**
+	 *	Get a configuration parameter as a String[].
+	 *	If undefined, return the specified default.
+	 *	@return String[]
+	 */
+	public String[] getStrings(String name, String[] deflt) {
+		return getStrings(name, deflt, "[ \t,]+", false);
+	}
+	/**
+	 *	Get a configuration parameter as a String[].
+	 *	If undefined, return the specified default
+	 *	@return String[]
+	 */
+	public String[] getStrings(String name, String[] deflt, String pattern, boolean complain) {
+		name = getString(name, null, complain);
+		if (name == null) {
+			return deflt;
+		}
+		return name.trim().split(pattern);
+	}
+
+	/**
+	 *	Get a configuration parameter as a String[], each String encoded using URL % escapes.
+	 *	If undefined, return null and log an error.
+	 *	@return String[]
+	 */
+	public String[] getDecodedStrings(String name) {
+		return getDecodedStrings(name, null, "[ \t,]+", true);
+	}
+	/**
+	 *	Get a configuration parameter as a String[], each String encoded using URL % escapes.
+	 *	If undefined, return the specified default.
+	 *	@return String[]
+	 */
+	public String[] getDecodedStrings(String name, String[] deflt) {
+		return getDecodedStrings(name, deflt, "[ \t,]+", false);
+	}
+	/**
+	 *	Get a configuration parameter as a String[], each String encoded using URL % escapes.
+	 *	If undefined, return the specified default.
+	 *	@return String[]
+	 */
+	public String[] getDecodedStrings(String name, String[] deflt, String pattern) {
+		return getDecodedStrings(name, deflt, pattern, false);
+	}
+	/**
+	 *	Get a configuration parameter as a String[], each String encoded using URL % escapes.
+	 *	If undefined, return the specified default.
+	 *	@return String[]
+	 */
+	public String[] getDecodedStrings(String name, String[] deflt, String pattern, boolean complain) {
+		name = getString(name, null, complain);
+		if (name == null) {
+			return deflt;
+		}
+		String[] strs = (name.trim().split(pattern));
+		try {
+			for (int i = 0; i < strs.length; i++) {
+				strs[i] = URLDecoder.decode(strs[i], "UTF-8");
+			}
+		} catch (UnsupportedEncodingException e) {
+		    logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0007: UTF-8 is not recognized as a character set encoding", e);
+		}
+		return strs;
+	}
+
+	/**
+	 *	Get a configuration parameter as a long.  If undefined or non-numeric, return -1 and log an error.
+	 */
+	public long getLong(String name) {
+		return getLong(name, -1L);
+	}
+	/**
+	 *	Get a configuration parameter as a long.  If undefined, return the specified default
+	 *	If non-numeric, return the specified default and log an error.
+	 */
+	public long getLong(String name, long deflt) {
+		String value = getString(name, null);
+		if (value == null) {
+			return deflt;
+		}
+		try {
+			return Long.parseLong(value.trim());
+		} catch (Exception e) {
+		    logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0002: '" + filename + "': Configuration property " + name + " must be numeric", e);
+			return deflt;
+		}
+	}
+
+	/**
+	 *	Get a configuration parameter as an int.  If undefined or non-numeric, return -1 and log an error.
+	 */
+	public int getInt(String name) {
+		return getInt(name, -1);
+	}
+	/**
+	 *	Get a configuration parameter as an int.  If undefined, return the specified default
+	 *	If non-numeric, return the specified default and log an error.
+	 */
+	public int getInt(String name, int deflt) {
+		String value = getString(name, null);
+		if (value == null) {
+			return deflt;
+		}
+		try {
+			return Integer.parseInt(value.trim());
+		} catch (Exception e) {
+		    logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0002: '" + filename + "': Configuration property " + name + " must be numeric", e);
+			return deflt;
+		}
+	}
+
+	/**
+	 *	Get a configuration parameter as an boolean.  If undefined or non-numeric, return false and log an error.
+	 */
+	public boolean getBoolean(String name) {
+		return getBoolean(name, false);
+	}
+	/**
+	 *	Get a configuration parameter as an boolean.  If undefined, return the specified default
+	 *	If non-numeric, return the specified default and log an error.
+	 */
+	public boolean getBoolean(String name, boolean deflt) {
+		String value = getString(name, null);
+		if (value == null) {
+			return deflt;
+		}
+		try {
+			return Boolean.parseBoolean(value.trim());
+		} catch (Exception e) {
+		    logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0002: '" + filename + "': Configuration property " + name + " must be true/false", e);
+			return deflt;
+		}
+	}
+
+	/**
+	 *	Get a configuration parameter as a double.  If undefined or non-numeric, return -1 and log an error.
+	 */
+	public double getDouble(String name) {
+		return getDouble(name, -1);
+	}
+	/**
+	 *	Get a configuration parameter as a double.  If undefined, return the specified default
+	 *	If non-numeric, return the specified default and log an error.
+	 */
+	public double getDouble(String name, double deflt) {
+		String value = getString(name, null);
+		if (value == null) {
+			return deflt;
+		}
+		try {
+			return Double.parseDouble(value);
+		} catch (Exception e) {
+		    logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0002: '" + filename + "': Configuration property " + name + " must be numeric", e);
+			return deflt;
+		}
+	}
+
+	public Enumeration getKeys() {
+		checkinit();
+		return (config != null) ? config.getKeys() : null;
+	}
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/ConfigurationRegistry.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/ConfigurationRegistry.java
new file mode 100644
index 0000000..a8241f8
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/ConfigurationRegistry.java
@@ -0,0 +1,106 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.config;
+
+import java.util.logging.*;
+import java.lang.ref.*;
+
+/**
+ *	Class to register and notify other objects when needed.
+ *	Those other objects must implement Configurable.
+ */
+
+public class ConfigurationRegistry {
+	public ConfigurationRegistry() { }
+
+	/**
+	 *	The set of registered configurables
+	 */
+	private WeakReference<Configurable>[] configurables = new WeakReference[0];
+
+	/**
+	 *	Request callback whenever the configuration data changes
+	 */
+	public synchronized void registerConfigurable(Configurable element) {
+		// System.out.println("adding " + element.getClass().getName() + ", length=" + Integer.toString(configurables.length));
+		for (int i = 0; i < configurables.length; i++) {
+			if (configurables[i].get() == element) {
+				return;
+			}
+		}
+		WeakReference<Configurable>[] nconfigurables = new WeakReference[configurables.length + 1];
+		System.arraycopy(configurables, 0, nconfigurables, 0, configurables.length);
+		nconfigurables[configurables.length] = new WeakReference<Configurable>(element);
+		configurables = nconfigurables;
+		element.reConfigure();
+	}
+
+	/**
+	 *	Cancel request for callbacks when configuration changes
+	 */
+	public synchronized void deRegisterConfigurable(Configurable element) {
+		// System.out.println("removing " + element.getClass().getName() + ", length=" + Integer.toString(configurables.length));
+		for (int i = 0; i < configurables.length; i++) {
+			if (configurables[i].get() == element) {
+				WeakReference<Configurable>[] nconfigurables = new WeakReference[configurables.length - 1];
+				if (i > 0) {
+					System.arraycopy(configurables, 0, nconfigurables, 0, i);
+				}
+				if (i < nconfigurables.length) {
+					System.arraycopy(configurables, i + 1, nconfigurables, i, nconfigurables.length - i);
+				}
+				configurables = nconfigurables;
+				return;
+			}
+		}
+	}
+
+	/**
+	 *	Notify all of the Configurables that they need to reConfigure.
+	 */
+	public void reConfigureAll() {
+	    reConfigureAll(Logger.getLogger(ConfigurationRegistry.class.getName()));
+	}
+
+	/**
+	 *	Notify all of the Configurables that they need to reConfigure.
+	 */
+	public void reConfigureAll(Logger logger) {
+		// System.out.println("reConfigureAll(), length=" + Integer.toString(configurables.length));
+		for (int i = 0; i < configurables.length; i++) {
+			try {
+				// System.out.println("reConfigureAll(), i=" + Integer.toString(i));
+				WeakReference<Configurable> wc = configurables[i];
+				Configurable c = (wc != null) ? wc.get() : null;
+				if (c != null)
+					c.reConfigure();
+			} catch (Exception e) {
+				WeakReference<Configurable> wc = configurables[i];
+				Configurable c = (wc != null) ? wc.get() : null;
+				logger.log(Level.SEVERE, "DAIS0048 Unrecoverable configuration error CNFG0005: Problem while invoking reConfigure for: " +
+				    ((wc == null) ? "null" : (c == null) ? "null/null" : c.getClass().getName()) + ": " +
+				    e.getMessage(), e);
+			}
+		}
+	}
+
+	/**
+	 *	Return the number of configurables that are registered.
+	 */
+	public int getCount() {
+	    return configurables.length;
+	}
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/EncryptedConfiguration.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/EncryptedConfiguration.java
new file mode 100644
index 0000000..9c546dc
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/EncryptedConfiguration.java
@@ -0,0 +1,219 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.config;
+
+import java.util.logging.*;
+// import java.lang.ref.*;
+import org.openecomp.dcae.cdf.util.common.*;
+import gnu.getopt.Getopt;
+import java.security.*;
+import javax.crypto.*;
+import javax.crypto.spec.SecretKeySpec;
+
+/**
+ *	Class to manage encrypted configuration values.
+ */
+
+public class EncryptedConfiguration {
+    /**
+     *	Our secret key
+     */
+    private String encryptionKey;
+
+    /**
+     *	Where to log when things go wrong
+     */
+    private Logger logger;
+
+    public EncryptedConfiguration(String key, Logger logger) {
+	encryptionKey = key.trim();
+	this.logger = logger;
+    }
+
+    /**
+     * Retrieve an encrypted string from the given configuration.
+     * The name will have ".x" appended to it.
+     * Decoded from hex, it will be "method:hexsalt:hexvalue".
+     * The format of the value will be in hex.
+     * Method will be "r" to begin with, for "rc4".
+     */
+    public String getString(Configuration config, String name, String deflt, boolean complain) throws Exception {
+        return getString(config, name, deflt, complain, encryptionKey);
+    }
+
+    /**
+     * Retrieve an encrypted string from the given configuration.
+     * The name will have ".x" appended to it.
+     * Decoded from hex, it will be "method:hexsalt:hexvalue".
+     * The format of the value will be in hex.
+     * Method will be "r" to begin with, for "rc4".
+     */
+    public String getString(Configuration config, String name, String deflt, boolean complain, String key) throws Exception {
+	String str = config.getString(name + ".x", null, complain);
+	if (str == null) {
+	    return deflt;
+	}
+	return decrypt(str, key);
+    }
+
+    /**
+     * Decrypt a string in 'method:hexsalt:hexvalue' format.
+     */
+    public static String decrypt(String triple, String key) throws Exception {
+	String[] strParts = triple.trim().split(":");
+	if (strParts.length != 3) throw new Exception("Encrypted value must look like 'x:y:z'");
+	return decrypt(strParts[0], Convert.stringFromHex(strParts[1]), key, Convert.bytesFromHex(strParts[2]));
+    }
+
+    /**
+     * Decrypt a string 'method:hexsalt:hexvalue' format.
+     */
+    public static String decrypt(String method, String salt, String key, byte[] bvalue) throws Exception {
+	/* if (false) {
+	    System.out.println("method length=" + method.length()); System.out.println(AsHex.asHex(method));
+	    System.out.println("salt length=" + salt.length()); System.out.println(AsHex.asHex(salt));
+	    System.out.println("key length=" + key.length()); System.out.println(AsHex.asHex(key));
+	    System.out.println("bvalue length=" + bvalue.length); System.out.println(AsHex.asHex(bvalue));
+	    } */
+	byte[] secretKey = runDigest(salt + "." + key);
+
+	SecretKeySpec skeySpec = new SecretKeySpec(secretKey, method);
+
+	Cipher cipher = Cipher.getInstance(method);	// "AES"
+	cipher.init(Cipher.DECRYPT_MODE, skeySpec);
+
+	byte[] decrypted = cipher.doFinal(bvalue);
+	return new String(decrypted);
+    }
+
+    /**
+     * Encrypt a string using the given method, salt and key.
+     */
+    public static byte[] encrypt(String method, String salt, String key, String value) throws Exception {
+	byte[] bvalue = value.getBytes();
+	byte[] secretKey = runDigest(salt + "." + key);
+
+	SecretKeySpec skeySpec = new SecretKeySpec(secretKey, method);
+
+	Cipher cipher = Cipher.getInstance(method);	// "AES"
+	cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
+
+	byte[] encrypted = cipher.doFinal(bvalue);
+	return encrypted;
+    }
+
+    /**
+     * Prepare a secret key by running a digest on it.
+     */
+    private static byte[] runDigest(String text) throws Exception {
+	MessageDigest md = MessageDigest.getInstance("MD5");
+	md.reset();
+	md.update(text.getBytes(), 0, text.length());
+	return md.digest();
+    }
+
+    /**
+     * Encrypt a string using the given method, salt and key, and return it as a hex-formated triple.
+     */
+    public static String encryptToTriple(String method, String salt, String key, String value) throws Exception {
+	StringBuilder sb = new StringBuilder(method);
+	sb.append(':').append(Convert.toHexString(salt))
+	  .append(':').append(Convert.toHexString(encrypt(method, salt, key, value)));
+	return sb.toString();
+    }
+
+    /**
+     * Create a value that can be used as a salt.
+     */
+    public static String generateSalt() {
+	return Long.toString(System.currentTimeMillis() % 1000) + Pid.getPidStr();
+    }
+
+    public static void usage() {
+	usage(null);
+    }
+
+    public static void usage(String msg) {
+	if (msg != null) System.out.println(msg);
+	System.out.println("Usage: java EncryptedConfiguration -D triple -k key\n" +
+	    "java EncryptedConfiguration -d string -m method [-s salt | -S] -k key\n" +
+	    "java EncryptedConfiguration -e string -m method [-s salt | -S] -k key\n" +
+	    "-D\tdecrypt x:y:z triple\n" +
+	    "-d\tdecrypt string (in hex)\n" +
+	    "-e\tencrypt string\n" +
+	    "-S\tgenerate a salt\n"
+	    );
+	System.exit(1);
+    }
+
+    public static void main(String args[]) throws Exception {
+	Getopt g = new Getopt( "EncryptedConfiguration", args, "s:Sk:m:e:d:D:?" );
+
+	int c, verbosity = 0;
+	String salt = null, key = null, method = null, encStr = null, decStr = null, triple = null;
+	boolean genSalt = false;
+
+	while ((c = g.getopt()) != -1) {
+	    switch (c) {
+		case 's': salt = g.getOptarg(); break;
+	        case 'S': genSalt = true; break;
+		case 'k': key = g.getOptarg(); break;
+		case 'm': method = g.getOptarg(); break;
+		case 'e': encStr = g.getOptarg(); break;
+		case 'd': decStr = g.getOptarg(); break;
+		case 'D': triple = g.getOptarg(); break;
+		case '?': usage(); break;
+	    }
+	}
+
+	if (triple == null) {
+	    if ((salt == null) && !genSalt) usage("one of -s or -S must be specified");
+	    if ((salt != null) && genSalt) usage("only one of -s or -S must be specified");
+	    if (key == null) usage("-k must be specified");
+	    if (method == null) usage("-m must be specified");
+	    if ((encStr == null) && (decStr == null)) usage("one of -d or -e must be specified");
+	    if ((encStr != null) && (decStr != null)) usage("only one of -d or -e may be specified");
+	    if (genSalt) salt = generateSalt();
+	    if (encStr != null)
+		System.out.println(encryptToTriple(method, salt, key, encStr));
+	    if (decStr != null)
+		System.out.println(decrypt(method, salt, key, Convert.bytesFromHex(decStr)));
+	} else {
+	    if (key == null) usage("-k not specified");
+	    System.out.println(decrypt(triple, key));
+	}
+
+	// http://forums.sun.com/thread.jspa?threadID=5290983
+	// try {
+	//     String message = "Strong Versus Unlimited Strength Cryptography";
+	//     SecretKeySpec skeySpec = new SecretKeySpec("0123456789ABCDEF".getBytes(), "AES"); //AES-128
+
+	//     Cipher cipher = Cipher.getInstance("AES");	// "AES/ECB/NoPadding"
+	//     cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
+
+	//     byte[] encrypted = cipher.doFinal(message.getBytes());
+	//     System.out.println("encrypted string: " + encrypted); //storing into MySQL DB
+	//     System.out.println("in hex: '" + Convert.toHexString(encrypted) + "'");
+
+	//     cipher.init(Cipher.DECRYPT_MODE, skeySpec);
+	//     byte[] original = cipher.doFinal(encrypted);
+	//     String originalString = new String(original);
+	//     System.out.println("Original string: " + originalString);
+	// } catch (Exception e) {
+	//     System.err.println("Exception caught: " + e.toString());
+	// }
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/PropValue.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/PropValue.java
new file mode 100644
index 0000000..07bbe06
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/config/PropValue.java
@@ -0,0 +1,245 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.config;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.BufferedReader;
+import java.io.PrintStream;
+import java.io.IOException;
+import java.util.logging.Logger;
+import org.openecomp.dcae.cdf.util.config.Configuration;
+import org.openecomp.dcae.cdf.util.config.EncryptedConfiguration;
+import gnu.getopt.Getopt;
+
+public class PropValue {
+    private EncryptedConfiguration encryptedConfiguration;
+    private String encryptionKey;
+
+    public PropValue(Configuration globalConfig, Logger logger) {
+	encryptionKey = globalConfig.getString(getEncryptionKeyProperty());
+	encryptedConfiguration = new EncryptedConfiguration(encryptionKey, logger);
+    }
+
+    public String getEncryptedString(Configuration config, String name, String deflt, boolean complain) throws Exception {
+	return encryptedConfiguration.getString(config, name, deflt, complain);
+    }
+
+    public String generateEncryptedProperty(String method, String salt, String value) throws Exception {
+	return generateEncryptedProperty(method, salt, value, this);
+    }
+
+    public String decryptTriple(String triple) {
+	return decryptTriple(triple, this);
+    }
+
+    public static void printEncryptedProperty(String method, String name, String salt, String value, String globalPropFile) {
+	try {
+	    if (name != null) System.out.print(name + ".x=");
+	    if (globalPropFile == null) globalPropFile = getGlobalPropFile();
+	    if (globalPropFile == null) throw new NullPointerException("globalPropFile not set");
+	    System.out.println(generateEncryptedProperty(method, salt, value, globalPropFile));
+	} catch (Exception e) {
+	    System.err.println("Cannot encrypt '" + value + "', method '" + method + "' for property '" + name + "': "+ e.toString());
+	}
+    }
+
+    public static String generateEncryptedProperty(String method, String salt, String value, String globalPropFile) throws Exception {
+	Logger logger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
+	if (globalPropFile == null) globalPropFile = getGlobalPropFile();
+	if (globalPropFile == null) throw new NullPointerException("globalPropFile not set");
+	PropValue propValue = new PropValue(new Configuration(globalPropFile), logger);
+	return generateEncryptedProperty(method, salt, value, propValue);
+    }
+
+    public static String generateEncryptedProperty(String method, String salt, String value, PropValue propValue) throws Exception {
+	if (salt == null) salt = EncryptedConfiguration.generateSalt();
+	return EncryptedConfiguration.encryptToTriple(method, salt, propValue.encryptionKey, value);
+    }
+
+    public static void extractProperty(String f, String name, boolean encrypted) {
+	extractProperty(f, name, encrypted, null);
+    }
+
+    public static void extractProperty(String f, String name, boolean encrypted, String globalPropFile) {
+	Configuration config = new Configuration(f);
+	Logger logger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
+	if (globalPropFile == null) globalPropFile = getGlobalPropFile();
+	if (globalPropFile == null) throw new NullPointerException("globalPropFile not set");
+	PropValue propValue = new PropValue(new Configuration(globalPropFile), logger);
+	String val = "";
+	try {
+	    if (encrypted)
+		val = propValue.getEncryptedString(config, name, "", true);
+	    else
+		val = config.getString(name);
+	    System.out.println(val);
+	} catch (Exception e) {
+	    System.err.println("Cannot extract '" + name + "' from '" + config + "': " + e.toString());
+	}
+    }
+
+    public static void usage() {
+	usage(null);
+    }
+
+    //    public static String decryptTriple(String triple) {
+    //	return decryptTriple(triple, null);
+    //    }
+
+    public static String decryptTriple(String triple, String globalPropFile) {
+	Logger logger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
+	if (globalPropFile == null) globalPropFile = getGlobalPropFile();
+	if (globalPropFile == null) throw new NullPointerException("globalPropFile not set");
+	PropValue propValue = new PropValue(new Configuration(globalPropFile), logger);
+	return decryptTriple(triple, propValue);
+    }
+
+    public static String decryptTriple(String triple, PropValue propValue) {
+	String ret = null;
+	try {
+	    ret = EncryptedConfiguration.decrypt(triple, propValue.encryptionKey);
+	} catch (Exception e) {
+	    System.err.println("Cannot decrypt '" + triple + "': " + e.toString());
+	}
+	return ret;
+    }
+
+    public static void encryptInput(InputStream in, PrintStream out) throws Exception {
+	encryptInput(null, in, out);
+    }
+    public static void encryptInput() throws Exception {
+	encryptInput(null, System.in, System.out);
+    }
+
+    private static void printEncryptedValue(Matcher m, PropValue propValue, PrintStream sysout) {
+	String method = m.group(1);
+	String name = m.group(2);
+	String value = m.group(3);
+	try {
+	    sysout.println(name + ".x=" +
+			   EncryptedConfiguration.encryptToTriple(method,
+								  EncryptedConfiguration.generateSalt(),
+								  propValue.encryptionKey, value));
+	} catch (Exception e) {
+	    System.err.println("Error: Cannot encrypt '" + value + "', method '" + method + "' for property '" + name + "': " + e.toString());
+	}
+    }
+
+    public static void encryptInput(String globalPropFile, InputStream sysin, PrintStream sysout) throws Exception {
+	String s;
+
+	Pattern pDquote = Pattern.compile("^ENCRYPTME[.]([A-Z]*)[.]([^= \t]*)[ \t]*=[ \t]*\"([^\"]*)\"[ \t]*$");
+	Pattern pSquote = Pattern.compile("^ENCRYPTME[.]([A-Z]*)[.]([^= \t]*)[ \t]*=[ \t]*'([^']*)'[ \t]*$");
+	Pattern pNoWhite = Pattern.compile("^ENCRYPTME[.]([A-Z]*)[.]([^= \t]*)[ \t]*=[ \t]*([^ \t'\"]+)[ \t]*$");
+//	Pattern pEncryptMe = Pattern.compile("^ENCRYPTME[.]([A-Z]*)[.]([^= \t]*)[ \t]*=");
+
+	Logger logger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
+	if (globalPropFile == null) globalPropFile = getGlobalPropFile();
+	if (globalPropFile == null) throw new NullPointerException("globalPropFile not set");
+	PropValue propValue = new PropValue(new Configuration(globalPropFile), logger);
+
+	BufferedReader in = new BufferedReader(new InputStreamReader(sysin));
+
+	try {
+	    while ((s = in.readLine()) != null) {
+		// System.out.println("looking at '" + s + "'");
+		Matcher mDquote = pDquote.matcher(s);
+		Matcher mSquote = pSquote.matcher(s);
+		Matcher mNoWhite = pNoWhite.matcher(s);
+//		Matcher mEncryptMe = pNoWhite.matcher(s);
+		if (mDquote.matches()) {
+		    printEncryptedValue(mDquote, propValue, sysout);
+		} else if (mSquote.matches()) {
+		    printEncryptedValue(mSquote, propValue, sysout);
+		} else if (mNoWhite.matches()) {
+		    printEncryptedValue(mNoWhite, propValue, sysout);
+		} else if (s.startsWith("ENCRYPTME")) {
+		    throw new Exception("Bad value to encrypt: '" + s + "'");
+		} else {
+		    // System.out.println("printing the line: '" + s + "'");
+		    sysout.println(s);
+		}
+	    }
+	} catch (IOException e) {
+	    System.err.println("Error: Cannot read from stdin: " + e.toString());
+	} catch (Exception e) {
+	    throw e;
+	}
+    }
+
+    public static void usage(String msg) {
+	if (msg != null) System.err.println(msg);
+	System.err.println("Usage: java PropValue [-x] -n property -f property-file");
+	System.err.println("\tExtract the named value from the given property-file (or full pathname)");
+	System.err.println("Usage: java PropValue -e method [-n property] [-s salt] -v value");
+	System.err.println("\tEncrypt the given property with the given name and value");
+	System.err.println("Usage: java PropValue -E");
+	System.err.println("\tEncrypt all lines that look like ENCRYPTME.METHOD.name=value");
+	System.err.println("Usage: java PropValue -u value");
+	System.err.println("\tDecrypt the given value, expressed as a triple METHOD:HEXSALT:HEXVAL");
+	System.exit(1);
+    }
+
+    public static void setGlobalPropFile(String g) { sGlobalPropFile = g; }
+    public static String getGlobalPropFile() { return sGlobalPropFile; }
+    private static String sGlobalPropFile = null;
+
+    public static void setEncryptionKeyProperty(String e) { encryptionKeyProperty = e; }
+    public static String getEncryptionKeyProperty() { return encryptionKeyProperty; }
+    private static String encryptionKeyProperty = "Global_Title";
+
+    public static void main(String args[]) throws Exception {
+	Getopt g = new Getopt( "PropValue", args, "e:Ef:G:n:s:u:v:x" );
+	String propfile = null, name = null, method = null, value = null, unencrypt = null;
+	String globalPropFile = getGlobalPropFile();
+	boolean useDecryption = false, encryptStdin = false;
+	String salt = null;
+	int c;
+
+	while ((c = g.getopt()) != -1) {
+	    switch (c) {
+		case 'e': method = g.getOptarg(); break;
+	        case 'E': encryptStdin = true; break;
+		case 'f': propfile = g.getOptarg(); break;
+		case 'G': globalPropFile = g.getOptarg(); break;
+		case 'n': name = g.getOptarg(); break;
+		case 's': salt = g.getOptarg(); break;
+	        case 'u': unencrypt = g.getOptarg(); break;
+		case 'v': value = g.getOptarg(); break;
+		case 'x': useDecryption = true; break;
+		case '?': usage(); break;
+	    }
+	}
+	if (encryptStdin) {
+	    if (name != null || propfile != null || method != null || value != null) usage("cannot use -E with other options");
+	    encryptInput(System.in, System.out);
+	} else if (unencrypt == null) {
+	    if (method != null) {
+		if (value == null) usage("-v required");
+		printEncryptedProperty(method, name, salt, value, globalPropFile);
+	    } else {
+		if (name == null) usage("-n is required");
+		if (propfile == null) usage("-f is required");
+		extractProperty(propfile, name, useDecryption, globalPropFile);
+	    }
+	} else {
+	    System.out.println(decryptTriple(unencrypt, globalPropFile));
+	}
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/threads/.gitignore b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/threads/.gitignore
new file mode 100644
index 0000000..6b468b6
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/threads/.gitignore
@@ -0,0 +1 @@
+*.class
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/threads/TaskThread.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/threads/TaskThread.java
new file mode 100644
index 0000000..2fee87a
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/threads/TaskThread.java
@@ -0,0 +1,164 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.threads;
+
+/**
+ *	A thread with a queue of runnable tasks to execute in the
+ *	thread
+ */
+public class TaskThread extends Thread	{
+	/**
+	 *	Allocates a new TaskThread object.
+	 */
+	public TaskThread() {
+	}
+	/**
+	 *	Allocates a new TaskThread object.
+	 */
+	public TaskThread(Runnable target) {
+		super(target);
+	}
+	/**
+	 *	Allocates a new TaskThread object.
+	 */
+	public TaskThread(ThreadGroup group, Runnable target) {
+		super(group, target);
+	}
+	/**
+	 *	Allocates a new TaskThread object.
+	 */
+	public TaskThread(String name) {
+		super(name);
+	}
+	/**
+	 *	Allocates a new TaskThread object.
+	 */
+	public TaskThread(ThreadGroup group, String name) {
+		super(group, name);
+	}
+	/**
+	 *	Allocates a new TaskThread object.
+	 */
+	public TaskThread(Runnable target, String name) {
+		super(target, name);
+	}
+	/**
+	 *	Allocates a new TaskThread object.
+	 */
+	public TaskThread(ThreadGroup group, Runnable target, String name) {
+		super(group, target, name);
+	}
+	/**
+	 *	A queued request to be run in the TaskThread
+	 */
+	private static class Task	{
+		public Task	next;
+		public Runnable	target;
+		public Task(Runnable target) {
+			this.target = target;
+		}
+	}
+	private Task	head;
+	private Task	tail;
+	protected boolean	closed;
+	/**
+	 *	Queue up a task to be executed by this thread.
+	 */
+	protected synchronized void queueRequest(Runnable r) {
+		Task t = new Task(r);
+		if (head == null) {
+			head = t;
+			wakeup();
+		} else {
+			tail.next = t;
+		}
+		tail = t;
+	}
+	/**
+	 *	Mark as closed and wake up.
+	 */
+	protected synchronized void markClosed() {
+		if (!closed) {
+			closed = true;
+			wakeup();
+		}
+	}
+	/**
+	 *	Wait for the next queued request.  If closed, return
+	 *	null.  Relies on the default implementation of wakeup.
+	 */
+	protected synchronized Runnable waitNextRequest() {
+		Task t;
+		while ((t = head) == null && !closed) {
+			try {
+				wait();
+			} catch (Exception e) {
+			}
+		}
+		head = t.next;
+		if (head == null) {
+			tail = null;
+		}
+		return t.target;
+	}
+	/**
+	 *	Get the next queued request or null if none
+	 */
+	protected synchronized Runnable nextRequest() {
+		Task t = head;
+		if (t == null) {
+			return null;
+		}
+		head = t.next;
+		if (head == null) {
+			tail = null;
+		}
+		return t.target;
+	}
+	/**
+	 *	Wake up the thread to process tasks.
+	 *	Implementation depends on what the thread
+	 *	is waiting on.  The default implementation
+	 *	does a this.notify().
+	 */
+	protected void wakeup() {
+		notify();
+	}
+	/**
+	 *	Process any pending requests then return
+	 */
+	protected void processQueuedRequests() {
+		Runnable r;
+		while ((r = nextRequest()) != null) {
+			r.run();
+		}
+	}
+	/**
+	 *	Check whether any tasks are pending
+	 */
+	protected boolean areTasksPending() {
+		return (head != null);
+	}
+	/**
+	 *	Wait for and process pending requests until closed
+	 */
+	protected void processRequestsForever() {
+		Runnable r;
+		while ((r = waitNextRequest()) != null) {
+			r.run();
+		}
+	}
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/threads/ThreadCommon.java b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/threads/ThreadCommon.java
new file mode 100644
index 0000000..fd9f3c1
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/main/java/org/openecomp/dcae/cdf/util/threads/ThreadCommon.java
@@ -0,0 +1,119 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.  
+ 
+    Licensed under the Apache License, Version 2.0 (the "License"); 
+    you may not use this code 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.openecomp.dcae.cdf.util.threads;
+
+/**
+ *    Some functions to manipulate thread info. Based on
+ *	http://nadeausoftware.com/articles/2008/04/java_tip_how_list_and_find_threads_and_thread_groups
+ *	which is licensed under LGPL 2
+ */
+
+import java.lang.management.*;
+// import java.util.Arrays;
+
+public final class ThreadCommon {
+    /**
+     * ThreadCommon is not to be instantiated.
+     */
+    private ThreadCommon() { }
+
+    private static ThreadGroup rootThreadGroup = null;
+
+    /**
+     * Get the root thread group in the thread group tree.
+     * Since there is always a root thread group, this
+     * method never returns null.
+     *
+     * @return		the root thread group
+     */
+    public static synchronized ThreadGroup getRootThreadGroup() {
+	if ( rootThreadGroup != null )
+	    return rootThreadGroup;
+	ThreadGroup tg = Thread.currentThread().getThreadGroup();
+	ThreadGroup ptg;
+	while ( (ptg = tg.getParent()) != null )
+	    tg = ptg;
+	return tg;
+    }
+
+    /**
+     * Get a list of all threads.  Since there is always at
+     * least one thread, this method never returns null or
+     * an empty array.
+     *
+     * @return		an array of threads
+     */
+    public static Thread[] getAllThreads() {
+	final ThreadGroup root = getRootThreadGroup();
+	final ThreadMXBean thbean = ManagementFactory.getThreadMXBean();
+	int nAlloc = thbean.getThreadCount();
+	int n = 0;
+	Thread[] threads;
+	do {
+	    nAlloc *= 2;
+	    threads = new Thread[ nAlloc ];
+	    n = root.enumerate( threads, true );
+	} while ( n == nAlloc );
+	return copyOf( threads, n );
+    }
+
+    /**
+     * Get the thread with the given name.  A null is returned
+     * if no such thread is found.  If more than one thread has
+     * the same name, the first one found is returned.
+     *
+     * @param	name	the thread name to search for
+     * @return		the thread, or null if not found
+     * @throws	NullPointerException
+     * 			if the name is null
+     */
+    public static Thread getFirstThread( final String name ) {
+	if ( name == null )
+	    throw new NullPointerException( "Null name" );
+	final Thread[] threads = getAllThreads();
+	for ( Thread thread : threads )
+	    if ( thread.getName().equals( name ) )
+		return thread;
+	return null;
+    }
+
+    /**
+     * Get a list of all threads with a given thread name.
+     *
+     * @param	name	the name to look for
+     * @return		an array of threads in that state
+     */
+    public static Thread[] getAllThreads( final String name ) {
+	if ( name == null )
+	    throw new NullPointerException( "Null name" );
+	final Thread[] allThreads = getAllThreads();
+	final Thread[] found = new Thread[allThreads.length];
+	int nFound = 0;
+	for ( Thread thread : allThreads )
+	    if ( thread.getName().equals(name) )
+		found[nFound++] = thread;
+	return copyOf( found, nFound );
+    }
+
+    // return java.util.Arrays.copyOf( found, nFound );
+    private static Thread[] copyOf( Thread[] threads, int n ) {
+	Thread[] nthreads = new Thread[ n ];
+	for (int i = 0; i < n; i++) {
+	    nthreads[i] = threads[i];
+	}
+	return nthreads;
+    }
+}
diff --git a/cdf/src/cdf-prop-value/cdf-util/src/test/java/org/openecomp/dcae/cdf/util/AppTest.java b/cdf/src/cdf-prop-value/cdf-util/src/test/java/org/openecomp/dcae/cdf/util/AppTest.java
new file mode 100644
index 0000000..85d5cd8
--- /dev/null
+++ b/cdf/src/cdf-prop-value/cdf-util/src/test/java/org/openecomp/dcae/cdf/util/AppTest.java
@@ -0,0 +1,53 @@
+/*
+    Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. 
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this code 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.openecomp.dcae.cdf.util;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest 
+    extends TestCase
+{
+    /**
+     * Create the test case
+     *
+     * @param testName name of the test case
+     */
+    public AppTest( String testName )
+    {
+        super( testName );
+    }
+
+    /**
+     * @return the suite of tests being tested
+     */
+    public static Test suite()
+    {
+        return new TestSuite( AppTest.class );
+    }
+
+    /**
+     * Rigourous Test :-)
+     */
+    public void testApp()
+    {
+        assertTrue( true );
+    }
+}
diff --git a/cdf/src/cdf-prop-value/makefile b/cdf/src/cdf-prop-value/makefile
new file mode 100644
index 0000000..194ad29
--- /dev/null
+++ b/cdf/src/cdf-prop-value/makefile
@@ -0,0 +1,13 @@
+all:
+
+build:
+	cd cdf-util/src/main/java && $(MAKE) build
+	cd cdf-prop-value/src/main/java && $(MAKE) build
+
+javadocs:
+	cd cdf-util/src/main/java && $(MAKE) javadocs
+	cd cdf-prop-value/src/main/java && $(MAKE) javadocs
+
+clean:
+	cd cdf-util/src/main/java && $(MAKE) clean
+	cd cdf-prop-value/src/main/java && $(MAKE) clean