diff --git a/kubernetes/aaf/charts/aaf-service/values.yaml b/kubernetes/aaf/charts/aaf-service/values.yaml
index 33c1644..b53e7a2 100644
--- a/kubernetes/aaf/charts/aaf-service/values.yaml
+++ b/kubernetes/aaf/charts/aaf-service/values.yaml
@@ -62,7 +62,7 @@
   internalPort: 8100
   #port
   externalPort: 8100
-  nodePort: 50
+  nodePort: 47
 
 ingress:
   enabled: false
diff --git a/kubernetes/aaf/charts/aaf-sms/charts/aaf-sms-quorumclient/values.yaml b/kubernetes/aaf/charts/aaf-sms/charts/aaf-sms-quorumclient/values.yaml
index d09d492..bb0f470 100644
--- a/kubernetes/aaf/charts/aaf-sms/charts/aaf-sms-quorumclient/values.yaml
+++ b/kubernetes/aaf/charts/aaf-sms/charts/aaf-sms-quorumclient/values.yaml
@@ -29,7 +29,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/aaf/smsquorumclient
+image: onap/aaf/smsquorumclient:latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/aaf/charts/aaf-sms/values.yaml b/kubernetes/aaf/charts/aaf-sms/values.yaml
index cd32539..0686ddb 100644
--- a/kubernetes/aaf/charts/aaf-sms/values.yaml
+++ b/kubernetes/aaf/charts/aaf-sms/values.yaml
@@ -29,7 +29,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/aaf/sms
+image: onap/aaf/sms:latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/aaf/resources/config/public/AAF_RootCA.cer b/kubernetes/aaf/resources/config/public/AAF_RootCA.cer
deleted file mode 100644
index e9a50d7..0000000
--- a/kubernetes/aaf/resources/config/public/AAF_RootCA.cer
+++ /dev/null
@@ -1,31 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFPjCCAyagAwIBAgIJAJ6u7cCnzrWdMA0GCSqGSIb3DQEBCwUAMCwxDjAMBgNV
-BAsMBU9TQUFGMQ0wCwYDVQQKDARPTkFQMQswCQYDVQQGEwJVUzAeFw0xODA0MDUx
-NDE1MjhaFw0zODAzMzExNDE1MjhaMCwxDjAMBgNVBAsMBU9TQUFGMQ0wCwYDVQQK
-DARPTkFQMQswCQYDVQQGEwJVUzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoC
-ggIBAMA5pkgRs7NhGG4ew5JouhyYakgYUyFaG121+/h8qbSdt0hVQv56+EA41Yq7
-XGie7RYDQK9NmAFF3gruE+6X7wvJiChp+Cyd7sFMnb65uWhxEdxWTM2BJFrgfzUn
-H8ZCxgaCo3XH4PzlKRy2LQQJEJECwl/RZmRCXijMt5e9h8XoZY/fKkKcZZUsWNCM
-pTo266wjvA9MXLmdgReRj0+vrCjrNqy+htwJDztoiHWiYPqT6o8EvGcgjNqjlZx7
-NUNf8MfLDByqKF6+wRbHv1GKjn3/Vijd45Fv8riyRYROiFanvbV6jIfBkv8PZbXg
-2VDWsYsgp8NAvMxK+iV8cO+Ck3lBI2GOPZbCEqpPVTYbLUz6sczAlCXwQoPzDIZY
-wYa3eR/gYLY1gP2iEVHORag3bLPap9ZX5E8DZkzTNTjovvLk8KaCmfcaUMJsBtDd
-ApcUitz10cnRyZc1sX3gE1f3DpzQM6t9C5sOVyRhDcSrKqqwb9m0Ss04XAS9FsqM
-P3UWYQyqDXSxlUAYaX892u8mV1hxnt2gjb22RloXMM6TovM3sSrJS0wH+l1nznd6
-aFXftS/G4ZVIVZ/LfT1is4StoyPWZCwwwly1z8qJQ/zhip5NgZTxQw4mi7ww35DY
-PdAQOCoajfSvFjqslQ/cPRi/MRCu079heVb5fQnnzVtnpFQRAgMBAAGjYzBhMB0G
-A1UdDgQWBBRTVTPyS+vQUbHBeJrBKDF77+rtSTAfBgNVHSMEGDAWgBRTVTPyS+vQ
-UbHBeJrBKDF77+rtSTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAN
-BgkqhkiG9w0BAQsFAAOCAgEAPx/IaK94n02wPxpnYTy+LVLIxwdq/kawNd6IbiMz
-L87zmNMDmHcGbfoRCj8OkhuggX9Lx1/CkhpXimuYsZOFQi5blr/u+v4mIbsgbmi9
-7j+cUHDP0zLycvSvxKHty51LwmaX9a4wkJl5zBU4O1sd/H9tWcEmwJ39ltKoBKBx
-c94Zc3iMm5ytRWGj+0rKzLDAXEWpoZ5bE5PLJauA6UDCxDLfs3FwhbS7uDggxYvf
-jySF5FCNET94oJ+m8s7VeHvoa8iPGKvXrIqdd7XDHnqJJlVKr7m9S0fMbyEB8ci2
-RtOXDt93ifY1uhoEtEykn4dqBSp8ezvNMnwoXdYPDvTd9uCAFeWFLVreBAWxd25h
-PsBTkZA5hpa/rA+mKv6Af4VBViYr8cz4dZCsFChuioVebe9ighrfjB//qKepFjPF
-CyjzKN1u0JKm/2x/ORqxkTONG8p3uDwoIOyimUcTtTMv42bfYD88RKakqSFXE9G+
-Z0LlaKABqfjK49o/tsAp+c5LoNlYllKhnetO3QAdraHwdmC36BhoghzR1jpX751A
-cZn2VH3Q4XKyp01cJNCJIrua+A+bx6zh3RyW6zIIkbRCbET+UD+4mr8WIcSE3mtR
-ZVlnhUDO4z9//WKMVzwS9Rh8/kuszrGFI1KQozXCHLrce3YP6RYZfOed79LXaRwX
-dYY=
------END CERTIFICATE-----
diff --git a/kubernetes/aaf/resources/config/public/README.txt b/kubernetes/aaf/resources/config/public/README.txt
new file mode 100644
index 0000000..48aaa96
--- /dev/null
+++ b/kubernetes/aaf/resources/config/public/README.txt
@@ -0,0 +1 @@
+Public directory left empty on purpose. Content of https://gerrit.onap.org/r/gitweb?p=aaf/authz.git;a=tree;f=auth/sample/public;h=1b387b7858134f80446f006b6d570fa534da3153;hb=refs/heads/master is cloned and mounted into AAF container volume via init container. This is done to dramatically reduce the size of configuration that was being put into a configmap that was exceeding helm configmap limit of 1MB per deployment.
diff --git a/kubernetes/aaf/resources/config/public/aaf_2_0.xsd b/kubernetes/aaf/resources/config/public/aaf_2_0.xsd
deleted file mode 100644
index 59d4331..0000000
--- a/kubernetes/aaf/resources/config/public/aaf_2_0.xsd
+++ /dev/null
@@ -1,527 +0,0 @@
-<!-- Used by AAF (ATT inc 2013) -->
-<xs:schema 
-	xmlns:xs="http://www.w3.org/2001/XMLSchema" 
-	xmlns:aaf="urn:aaf:v2_0" 
-	targetNamespace="urn:aaf:v2_0" 
-	elementFormDefault="qualified">
-	
-<!-- 
-	June 2, 2017, adding Roles, Perms, etc to NSRequest for Onboarding purposes.
-	
-	Note: jan 22, 2015.  Deprecating the "force" element in the "Request" Structure.  Do that
-	with Query Params. 
-	
-	Eliminate in 3.0 
- -->
-<!--
-	Errors
-	Note: This Error Structure has been made to conform to the AT&T TSS Policies
- -->
-	<xs:element name="error">
-		<xs:complexType>
-			<xs:sequence>
-				<!--
-				Unique message identifier of the format ‘ABCnnnn’ where ‘ABC’ is
-					either ‘SVC’ for Service Exceptions or ‘POL’ for Policy Exception.
-					Exception numbers may be in the	range of 0001 to 9999 where :
-					* 0001 to 0199 are reserved for	common exception messages
-					* 0200 to 0999 are reserved for Parlay Web Services specification use
-					* 1000-9999 are available for exceptions 
-				 -->
-				<xs:element name="messageId" type="xs:string" minOccurs="1" maxOccurs="1"/>
-				
-				<!-- 
-				Message text, with replacement
-					variables marked with %n, where n is
-					an index into the list of <variables>
-					elements, starting at 1
-				 -->
-				<xs:element name="text" type="xs:string" minOccurs="1" maxOccurs="1"/>
-				
-				<!-- 
-				List of zero or more strings that
-					represent the contents of the variables
-					used by the message text. -->
-				<xs:element name="variables" type="xs:string" minOccurs="0" maxOccurs="unbounded" />
-			</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-
-<!-- 
-	Requests
- -->
-	<xs:complexType name="Request">
-		<xs:sequence>
-			<xs:element name="start" type="xs:dateTime" minOccurs="1" maxOccurs="1" />
-			<xs:element name="end" type="xs:dateTime" minOccurs="1" maxOccurs="1"/>
-			<!-- Deprecated.  Use Query Command 
-			<xs:element name="force" type="xs:string" minOccurs="1" maxOccurs="1" default="false"/>
-			-->
-		</xs:sequence>
-	</xs:complexType>
-
-<!--
-	Keys
- -->
-    <xs:element name="keys">
-    	<xs:complexType>
-    		<xs:sequence>
-    			<xs:element name="key" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
-    		</xs:sequence>
-    	</xs:complexType>
-    </xs:element>
- 
- 
-<!-- 
-	Permissions 
--->	
-	<xs:complexType name = "pkey">
-		<xs:sequence>
-			<xs:element name="type" type="xs:string"/>
-			<xs:element name="instance" type="xs:string"/>
-			<xs:element name="action" type="xs:string"/>
-		</xs:sequence>
-	</xs:complexType>
-
-	<xs:element name="permKey">
-		<xs:complexType >
-			<xs:complexContent>
-				<xs:extension base="aaf:pkey" />
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-	
-	<xs:element name="perm">
-		<xs:complexType >
-			<xs:complexContent>
-				<xs:extension base="aaf:pkey">
-					<xs:sequence>					
-						<xs:element name="roles" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
-						<!-- Note: feb 23, 2015.  Added description field. Verify backward compatibility. JR -->
- 						<xs:element name="description" type="xs:string" minOccurs="0" maxOccurs="1"/>
- 						<!-- This data not filled in unless Requested  -->
- 						<xs:element name="ns" type="xs:string" minOccurs="0" maxOccurs="1"/>
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-	
-	<xs:element name="perms">
-		<xs:complexType>
-			<xs:sequence>
-				<xs:element ref="aaf:perm" minOccurs="0" maxOccurs="unbounded"/>
-			</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-
-	<xs:element name="permRequest">
-		<xs:complexType>
-			<xs:complexContent>
-				<xs:extension base="aaf:Request">
-					<xs:sequence>
-						<xs:element name="type" type="xs:string"/>
-						<xs:element name="instance" type="xs:string"/>
-						<xs:element name="action" type="xs:string"/>
-						<!-- Note: feb 23, 2015.  Added description field. Verify backward compatibility. JR -->
-						<xs:element name="description" type="xs:string" minOccurs="0" maxOccurs="1"/>
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-
-
-<!-- 
-	Roles 
--->	
-	<xs:complexType name="rkey">
-		<xs:sequence>
-			<xs:element name="name" type="xs:string"/>
-		</xs:sequence>
-	</xs:complexType>
-	
-	<xs:element name="roleKey">
-		<xs:complexType >
-			<xs:complexContent>
-				<xs:extension base="aaf:rkey" />
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-
-	<xs:element name="role">
-		<xs:complexType>
-			<xs:complexContent>
-				<xs:extension base="aaf:rkey">
-					<xs:sequence>
-						<xs:element name="perms" type="aaf:pkey" minOccurs="0" maxOccurs="unbounded"/>
-						<!-- Note: feb 23, 2015.  Added description field. Verify backward compatibility. JR -->
-						<xs:element name="description" type="xs:string" minOccurs="0" maxOccurs="1"/>
-						<!-- This data not filled in unless Requested  -->
- 						<xs:element name="ns" type="xs:string" minOccurs="0" maxOccurs="1"/>
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-	
-	<xs:element name="roles">
-		<xs:complexType>
-			<xs:sequence>
-				<xs:element ref="aaf:role" minOccurs="0" maxOccurs="unbounded"/>
-			</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-
-	<xs:element name="roleRequest">
-		<xs:complexType>
-			<xs:complexContent>
-				<xs:extension base="aaf:Request">
-					<xs:sequence>
-						<xs:element name="name" type="xs:string" minOccurs="1" maxOccurs="1"/>
-						<!-- Note: feb 23, 2015.  Added description field. Verify backward compatibility. JR -->
-						<xs:element name="description" type="xs:string" minOccurs="0" maxOccurs="1"/>
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-
-	<!-- Added userRole return types jg1555 9/16/2015 -->
-	<xs:element name="userRole">
-		<xs:complexType>
-			<xs:sequence>
-				<xs:element name="user" type="xs:string" minOccurs="1" maxOccurs="1"/>
-				<xs:element name="role" type="xs:string" minOccurs="1" maxOccurs="1"/>
-				<xs:element name="expires" type="xs:date" minOccurs="1" maxOccurs="1" />
-			</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-	
-	<!-- Added userRoles return types jg1555 9/16/2015 -->
-	<xs:element name="userRoles">
-		<xs:complexType>
-			<xs:sequence>
-				<xs:element ref="aaf:userRole" minOccurs="0" maxOccurs="unbounded"/>
-			</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-
-	<xs:element name="userRoleRequest">
-		<xs:complexType>
-			<xs:complexContent>
-				<xs:extension base="aaf:Request">
-					<xs:sequence>
-						<xs:element name="user" type="xs:string" minOccurs="1" maxOccurs="1"/>
-						<xs:element name="role" type="xs:string" minOccurs="1" maxOccurs="1"/>
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-	
-	<xs:element name="rolePermRequest">
-		<xs:complexType>
-			<xs:complexContent>
-				<xs:extension base="aaf:Request">
-					<xs:sequence>
-						<xs:element name="perm" type="aaf:pkey" minOccurs="1" maxOccurs="1"/>
-						<xs:element name="role" type="xs:string" minOccurs="1" maxOccurs="1"/>
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-	
-	<xs:element name="nsRequest">
-		<xs:complexType>
-			<xs:complexContent>
-				<xs:extension base="aaf:Request">
-					<xs:sequence>
-						<xs:element name="name" type="xs:string" minOccurs="1" maxOccurs="1"/>
-						<xs:element name="admin" type="xs:string" minOccurs="1" maxOccurs="unbounded"/>
-						<xs:element name="responsible" type="xs:string" minOccurs="1" maxOccurs="unbounded"/>
-						<!-- Note: feb 23, 2015.  Added description field. Verify backward compatibility. JR -->
-						<xs:element name="description" type="xs:string" minOccurs="0" maxOccurs="1"/>
-						<!-- Note: dec 11, 2015.  Request-able NS Type JG -->
-						<xs:element name="type" type="xs:string" minOccurs="0" maxOccurs="1"/>
-	
-						<!-- "scope" is deprecated and unused as of AAF 2.0.11.  It will be removed in future versions
-							<xs:element name="scope" type="xs:int" minOccurs="0" maxOccurs="1"/>
-							
-													
-						<xs:element ref="aaf:roleRequest" minOccurs="0" maxOccurs="unbounded"/>
-						<xs:element ref="aaf:permRequest" minOccurs="0" maxOccurs="unbounded"/>
-						<xs:element name="aaf_id" type="xs:string" minOccurs="0" maxOccurs="1"/>
-						<xs:element ref="aaf:userRoleRequest" minOccurs="0" maxOccurs="unbounded"/>
-						<xs:element name = "attrib" minOccurs="0" maxOccurs="unbounded">
-								<xs:complexType>
-									<xs:sequence>
-										<xs:element name = "key" type="xs:string" minOccurs="1" maxOccurs="1"/>
-										<xs:element name = "value" type="xs:string" minOccurs="0" maxOccurs="1"/>
-									</xs:sequence>
-								</xs:complexType>
-							</xs:element>
-
-							
-						-->
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-
-	<xs:element name="nsAttribRequest">
-		<xs:complexType>
-			<xs:complexContent>
-				<xs:extension base="aaf:Request">
-					<xs:sequence>
-						<xs:element name="ns" type="xs:string" minOccurs="1" maxOccurs="1"/>
-						<xs:element name = "attrib" minOccurs="0" maxOccurs="unbounded">
-							<xs:complexType>
-								<xs:sequence>
-									<xs:element name = "key" type="xs:string" minOccurs="1" maxOccurs="1"/>
-									<xs:element name = "value" type="xs:string" minOccurs="0" maxOccurs="1"/>
-								</xs:sequence>
-							</xs:complexType>
-						</xs:element>
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-
-	<xs:element name = "nss">
-		<xs:complexType>
-			<xs:sequence>
-				<xs:element name = "ns" minOccurs="0" maxOccurs="unbounded">
-					<xs:complexType>
-						<xs:sequence>
-							<xs:element name = "name" type = "xs:string" minOccurs="1" maxOccurs="1"/>
-							<xs:element name = "responsible" type = "xs:string" minOccurs="0" maxOccurs="unbounded"/>
-							<xs:element name = "admin" type = "xs:string" minOccurs="0" maxOccurs="unbounded"/>
-							<!-- Note: feb 23, 2015.  Added description field. Verify backward compatibility. JR -->
-							<xs:element name = "description" type = "xs:string" minOccurs="0" maxOccurs="1"/>
-							<!-- Note: Dec 16, 2015.  Added description field. Verify backward compatibility. JG -->
-							<xs:element name = "attrib" minOccurs="0" maxOccurs="unbounded">
-								<xs:complexType>
-									<xs:sequence>
-										<xs:element name = "key" type="xs:string" minOccurs="1" maxOccurs="1"/>
-										<xs:element name = "value" type="xs:string" minOccurs="0" maxOccurs="1"/>
-									</xs:sequence>
-								</xs:complexType>
-							</xs:element>
-						</xs:sequence>
-					</xs:complexType>
-				</xs:element>
-			</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-
-<!-- 
-	Users 
--->	
-	<xs:element name="users">
-		<xs:complexType>
-			<xs:sequence>
-		   		<xs:element name="user" minOccurs="0" maxOccurs="unbounded">
-		   			<xs:complexType>
-		   				<xs:sequence>
-				       		<xs:element name="id" type="xs:string"  minOccurs="1" maxOccurs="1" />
-				       		<!-- Changed type to dateTime, because of importance of Certs -->
-				       		<xs:element name="expires" type="xs:dateTime" minOccurs="1" maxOccurs="1" />
-				       		<!-- need to differentiate User Cred Types, jg1555 5/20/2015
-				       			 This Return Object is shared by multiple functions: 
-				       			 	Type is not returned for "UserRole", but only "Cred" 
-				       		-->
-				       		<xs:element name="type" type="xs:int" minOccurs="0" maxOccurs="1" />
-		   				</xs:sequence>
-		   			</xs:complexType>
-		   		</xs:element>
-		   	</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-
-<!-- 
-	Certs
-	Added jg1555 5/20/2015 to support identifying Certificate based Services
- -->
-	<xs:element name="certs">
-		<xs:complexType>
-			<xs:sequence>
-				<xs:element name="cert" minOccurs="0" maxOccurs="unbounded">
-					<xs:complexType>
-						<xs:sequence>
-							<xs:element name="id" type="xs:string" minOccurs="1" maxOccurs="1" />
-							<xs:element name="x500" type="xs:string" minOccurs="1" maxOccurs="1" />
-							<xs:element name="expires" type="xs:dateTime" minOccurs="1" maxOccurs="1" />
-							<xs:element name="fingerprint" type="xs:hexBinary" minOccurs="1" maxOccurs="1" />
-						</xs:sequence>
-					</xs:complexType>
-				</xs:element>
-			</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-
-<!-- 
-	Credentials 
--->	
-	<xs:element name="credRequest">
-		<xs:complexType>
-			<xs:complexContent>
-				<xs:extension base="aaf:Request">
-					<xs:sequence>
-						<xs:element name="id" type="xs:string"/>
-						<xs:element name="type" type="xs:int" minOccurs="0" maxOccurs="1"/>
-						<xs:choice >
-							<xs:element name="password" type="xs:string" />
-							<xs:element name="entry" type="xs:string" />
-						</xs:choice>
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-	
-<!--
-	Multi Request 
- -->
- 
-    <xs:element name="multiRequest"> 
-		<xs:complexType>
-			<xs:complexContent>
-				<xs:extension base="aaf:Request">
-					<xs:sequence>
-						<xs:element ref="aaf:nsRequest" minOccurs="0" maxOccurs="1"/>
-						<xs:element ref="aaf:nsAttribRequest" minOccurs="0" maxOccurs="unbounded"/>
-						<xs:element ref="aaf:roleRequest" minOccurs="0" maxOccurs="unbounded"/>
-						<xs:element ref="aaf:permRequest" minOccurs="0" maxOccurs="unbounded"/>
-						<xs:element ref="aaf:credRequest" minOccurs="0" maxOccurs="unbounded"/>
-						<xs:element ref="aaf:userRoleRequest" minOccurs="0" maxOccurs="unbounded"/>
-						<xs:element ref="aaf:rolePermRequest" minOccurs="0" maxOccurs="unbounded"/>
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-    </xs:element>
-	
-<!--
-	History 
- -->
- 	<xs:element name="history">
- 		<xs:complexType>
- 			<xs:sequence>
- 				<xs:element name="item" minOccurs="0" maxOccurs="unbounded">
-			 		<xs:complexType>
-			 			<xs:sequence>
-			 				<xs:element name="YYYYMM" type="xs:string" minOccurs="1" maxOccurs="1"/>
-			 				<xs:element name="timestamp" type="xs:dateTime" minOccurs="1" maxOccurs="1"/>
-			 				<xs:element name="subject" type="xs:string" minOccurs="1" maxOccurs="1"/>
-			 				<xs:element name="target" type = "xs:string" minOccurs="1" maxOccurs="1"/>
-			 				<xs:element name="action" type="xs:string" minOccurs="1" maxOccurs="1"/>
-			 				<xs:element name="memo" type="xs:string" minOccurs="1" maxOccurs="1"/>
-			 				<xs:element name="user" type="xs:string" minOccurs="1" maxOccurs="1"/>
-			 			</xs:sequence>
-			 		</xs:complexType>
-			 	</xs:element>
-		 	</xs:sequence>
-		 </xs:complexType>
- 	</xs:element>
- 
-<!-- 
-	Approvals
- -->
- 	<xs:complexType name="approval">
-	   <xs:sequence>
-	   	   <!-- Note, id is set by system -->
-	   	   <xs:element name="id" type="xs:string" minOccurs="0" maxOccurs="1"/>
-	   	   <xs:element name="ticket" type="xs:string"/>
-	       <xs:element name="user" type="xs:string"/>
-	       <xs:element name="approver" type="xs:string"/>
-	       <xs:element name="type" type="xs:string"/>
-	       <xs:element name="memo" type="xs:string"/>
-	       <xs:element name="updated" type="xs:dateTime"/>
-	       <xs:element name="status">
-			  <xs:simpleType>
-			    <xs:restriction base="xs:string">
-			      <xs:enumeration value="approve"/>
-			      <xs:enumeration value="reject"/>
-			      <xs:enumeration value="pending"/>
-			    </xs:restriction>
-			  </xs:simpleType>
-		   </xs:element> 	
-		   <xs:element name="operation">
-			  <xs:simpleType>
-			    <xs:restriction base="xs:string">
-			      <xs:enumeration value="C"/>
-			      <xs:enumeration value="U"/>
-			      <xs:enumeration value="D"/>
-			      <xs:enumeration value="G"/>
-			      <xs:enumeration value="UG"/>
-			    </xs:restriction>
-			  </xs:simpleType>
-		   </xs:element> 	
-	   </xs:sequence>
-	</xs:complexType>
-	<xs:element name="approvals">
-		<xs:complexType>
-			<xs:sequence>
-				<xs:element name="approvals" type="aaf:approval" minOccurs="1" maxOccurs="unbounded"/>
-			</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-	
-<!-- 
-	Delegates 
--->	
-	<xs:complexType name="delg">
-	   <xs:sequence>
-	       <xs:element name="user" type="xs:string"/>
-	       <xs:element name="delegate" type="xs:string"/>
-	       <xs:element name="expires" type="xs:date"/>
-	   </xs:sequence>
-	</xs:complexType>
-	
-	<xs:element name="delgRequest">
-		<xs:complexType>
-			<xs:complexContent>
-				<xs:extension base="aaf:Request">
-					<xs:sequence>
-				       <xs:element name="user" type="xs:string" minOccurs="1" maxOccurs="1"/>
-				       <xs:element name="delegate" type="xs:string" minOccurs="1" maxOccurs="1"/>
-					</xs:sequence>
-				</xs:extension>
-			</xs:complexContent>
-		</xs:complexType>
-	</xs:element>
-
-	<xs:element name="delgs">
-		<xs:complexType>
-			<xs:sequence>
-				<xs:element name="delgs" type="aaf:delg" minOccurs="0" maxOccurs="unbounded"/>
-			</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-	
-	<!-- jg 3/11/2015 New for 2.0.8 -->
-	<xs:element name="api">
-		<xs:complexType>
-			<xs:sequence>
-				<xs:element name="route" minOccurs="0" maxOccurs="unbounded">
-					<xs:complexType>
-						<xs:sequence>
-							<xs:element name="meth" type="xs:string" minOccurs="1" maxOccurs="1"/>
-							<xs:element name="path" type="xs:string" minOccurs="1" maxOccurs="1"/>
-							<xs:element name="param" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
-							<xs:element name="desc" type="xs:string" minOccurs="1" maxOccurs="1"/>
-							<xs:element name="comments" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
-							<xs:element name="contentType" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
-							<xs:element name="expected" type="xs:int" minOccurs="1" maxOccurs="1"/>
-							<xs:element name="explicitErr" type="xs:int" minOccurs="0" maxOccurs="unbounded"/>
-						</xs:sequence>	
-					</xs:complexType>
-				</xs:element>
-			</xs:sequence>
-		</xs:complexType>
-	</xs:element>
-</xs:schema>
\ No newline at end of file
diff --git a/kubernetes/aaf/resources/config/public/iframe_denied_test.html b/kubernetes/aaf/resources/config/public/iframe_denied_test.html
deleted file mode 100644
index 613e9c7..0000000
--- a/kubernetes/aaf/resources/config/public/iframe_denied_test.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<html>
-<body>
-
-<iframe src="https://mithrilcsp.sbc.com:8095/gui/home">
-  <p>Your browser does not support iframes.</p>
-</iframe>
-
-</body>
-</html>
diff --git a/kubernetes/aaf/resources/config/public/truststoreONAP.p12 b/kubernetes/aaf/resources/config/public/truststoreONAP.p12
deleted file mode 100644
index d01e856..0000000
--- a/kubernetes/aaf/resources/config/public/truststoreONAP.p12
+++ /dev/null
Binary files differ
diff --git a/kubernetes/aaf/resources/config/public/truststoreONAPall.jks b/kubernetes/aaf/resources/config/public/truststoreONAPall.jks
deleted file mode 100644
index ff844b1..0000000
--- a/kubernetes/aaf/resources/config/public/truststoreONAPall.jks
+++ /dev/null
Binary files differ
diff --git a/kubernetes/aaf/templates/configmap.yaml b/kubernetes/aaf/templates/configmap.yaml
index cfa57f7..9d21e05 100644
--- a/kubernetes/aaf/templates/configmap.yaml
+++ b/kubernetes/aaf/templates/configmap.yaml
@@ -23,14 +23,6 @@
 apiVersion: v1
 kind: ConfigMap
 metadata:
-  name: {{ .Release.Name }}-aaf-public
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/config/public/*").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
   name: {{ .Release.Name }}-aaf-local
   namespace: {{ include "common.namespace" . }}
 data:
diff --git a/kubernetes/aaf/templates/job.yaml b/kubernetes/aaf/templates/job.yaml
index 7ce871e..85c0940 100644
--- a/kubernetes/aaf/templates/job.yaml
+++ b/kubernetes/aaf/templates/job.yaml
@@ -29,6 +29,21 @@
         app: aaf-init-job
         release: {{ .Release.Name }}
     spec:
+      initContainers:
+      - name: {{ include "common.name" . }}-inject-config
+        command:
+        - /bin/bash
+        - -c
+        - >
+          git clone -b {{ .Values.config.gerritBranch }} --single-branch {{ .Values.config.gerritProject }} /tmp/gerrit;
+          echo "Clone complete. Copying from /tmp/gerrit/ to /public";
+          cp -rf /tmp/gerrit/auth/sample/public/* /public;
+          echo "Done.";
+        image: "{{ .Values.global.ubuntuInitRepository }}/{{ .Values.global.ubuntuInitImage }}"
+        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+        volumeMounts:
+        - name: aaf-public
+          mountPath: "/public"
       containers:
       - command: ["/bin/bash","-c","if [ ! -d /data/backup ]; then mkdir /data/data && cp -Ra /data1/data/..data/* /data/data/ && mkdir /data/etc && cp -Ra /data1/etc/..data/* data/etc/ && mkdir /data/backup && cp -Ra /data1/backup/..data/* /data/backup/ && cp -Ra /data1/public /data/ && cp -Ra /data1/local /data && mkdir -p /data/logs/oauth && mkdir -p /data/logs/hello && mkdir -p /data/logs/fs && mkdir -p /data/logs/gui && mkdir -p /data/logs/locate && mkdir -p /data/logs/cm && mkdir -p /data/logs/service; fi; exit 0"]
         image: "{{ .Values.global.readinessRepository }}/{{ .Values.global.readinessImage }}"
@@ -51,13 +66,13 @@
           name: aaf-public
           subPath: aaf_2_0.xsd
         - mountPath: /data1/public/truststoreONAP.p12
-          name: aaf-public-secret
+          name: aaf-public
           subPath: truststoreONAP.p12
         - mountPath: /data1/public/AAF_RootCA.cer
-          name: aaf-public-secret
+          name: aaf-public
           subPath: AAF_RootCA.cer
         - mountPath: /data1/public/truststoreONAPall.jks
-          name: aaf-public-secret
+          name: aaf-public
           subPath: truststoreONAPall.jks
         - mountPath: /data1/local/org.osaaf.location.props
           name: aaf-local
@@ -85,6 +100,8 @@
           subPath: org.osaaf.aaf.cm.p12
         - mountPath: /data1/backup
           name: aaf-backup
+        - mountPath: /share
+          name: aaf-public
         resources: 
 {{ toYaml .Values.resources | indent 12 }}
       {{- if .Values.nodeSelector }}
@@ -102,9 +119,6 @@
       - name: aaf-local-secret
         secret:
           secretName: {{ .Release.Name }}-aaf-local-secret
-      - name: aaf-public-secret
-        secret:
-          secretName: {{ .Release.Name }}-aaf-public-secret
       - name: aaf-etc
         configMap:
           name: {{ .Release.Name }}-aaf-etc
@@ -114,9 +128,6 @@
       - name: aaf-backup
         configMap:
           name: {{ .Release.Name }}-aaf-backup
-      - name: aaf-public
-        configMap:
-          name: {{ .Release.Name }}-aaf-public
       - name: aaf-data
         configMap:
           name: {{ .Release.Name }}-aaf-data
@@ -127,6 +138,8 @@
       {{- else }}
         emptyDir: {}
       {{- end }}
+      - name: aaf-public
+        emptyDir: {}
       restartPolicy: OnFailure
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/aaf/templates/secrets.yaml b/kubernetes/aaf/templates/secrets.yaml
index d67601c..fe876e1 100644
--- a/kubernetes/aaf/templates/secrets.yaml
+++ b/kubernetes/aaf/templates/secrets.yaml
@@ -28,20 +28,3 @@
 {{ (.Files.Glob "resources/config/local/org.osaaf.aaf.keyfile").AsSecrets | indent 2 }}
 {{ (.Files.Glob "resources/config/local/org.osaaf.aaf.cm.p12").AsSecrets | indent 2 }}
 type: Opaque
----
-apiVersion: v1
-kind: Secret
-metadata:
-  name: {{ .Release.Name}}-aaf-public-secret
-  namespace: {{ include "common.namespace" . }}
-  labels:
-    app: {{ include "common.name" . }}
-    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
-    release: {{ .Release.Name }}
-    heritage: {{ .Release.Service }}
-data:
-{{ (.Files.Glob "resources/config/public/truststoreONAP.p12").AsSecrets | indent 2 }}
-{{ (.Files.Glob "resources/config/public/AAF_RootCA.cer").AsSecrets | indent 2 }}
-{{ (.Files.Glob "resources/config/public/truststoreONAPall.jks").AsSecrets | indent 2 }}
-type: Opaque
-
diff --git a/kubernetes/aaf/values.yaml b/kubernetes/aaf/values.yaml
index 805d3d1..1724be8 100644
--- a/kubernetes/aaf/values.yaml
+++ b/kubernetes/aaf/values.yaml
@@ -20,6 +20,8 @@
   repositorySecret: eyJuZXh1czMub25hcC5vcmc6MTAwMDEiOnsidXNlcm5hbWUiOiJkb2NrZXIiLCJwYXNzd29yZCI6ImRvY2tlciIsImVtYWlsIjoiQCIsImF1dGgiOiJaRzlqYTJWeU9tUnZZMnRsY2c9PSJ9fQ==
   readinessRepository: oomk8s
   readinessImage: readiness-check:2.0.0
+  ubuntuInitRepository: registry.hub.docker.com
+  ubuntuInitImage: oomk8s/ubuntu-init:2.0.0
   persistence: 
     enabled: true
 
@@ -35,6 +37,9 @@
   helloServiceName: aaf-hello
   oauthServiceName: aaf-oauth
   csServiceName: aaf-cass
+  # gerrit branch where the latest aaf/auth/sample/public code exists
+  gerritProject: http://gerrit.onap.org/r/aaf/authz.git
+  gerritBranch: master
 
 # default number of instances
 replicaCount: 1
diff --git a/kubernetes/aai/charts/aai-babel/resources/config/logback.xml b/kubernetes/aai/charts/aai-babel/resources/config/logback.xml
index 63b8faf..f406dc8 100644
--- a/kubernetes/aai/charts/aai-babel/resources/config/logback.xml
+++ b/kubernetes/aai/charts/aai-babel/resources/config/logback.xml
@@ -4,7 +4,7 @@
   <include resource="org/springframework/boot/logging/logback/base.xml" />
 
   <property name="componentName" value="AAI-BAS" />
-  <property name="logDirectory" value="${APP_HOME}/logs/${componentName}" />
+  <property name="logDirectory" value="/var/log/onap/${componentName}" />
 
   <!-- default EELF log file names -->
   <property name="generalLogName" value="error" />
diff --git a/kubernetes/aai/charts/aai-babel/templates/deployment.yaml b/kubernetes/aai/charts/aai-babel/templates/deployment.yaml
index 15cd163..2aac029 100644
--- a/kubernetes/aai/charts/aai-babel/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-babel/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
@@ -75,7 +75,7 @@
             subPath: babel-auth.properties
           - mountPath: /opt/app/babel/config/auth
             name: {{ include "common.fullname" . }}-secrets
-          - mountPath: /logs
+          - mountPath: /var/log/onap
             name: {{ include "common.fullname" . }}-logs
           - mountPath: /opt/app/babel/config/logback.xml
             name: {{ include "common.fullname" . }}-config
@@ -90,6 +90,20 @@
         affinity:
 {{ toYaml .Values.affinity | indent 10 }}
         {{- end }}
+
+        # side car containers
+        - name: filebeat-onap
+          image: "{{ .Values.global.loggingRepository }}/{{ .Values.global.loggingImage }}"
+          imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+          volumeMounts:
+          - mountPath: /usr/share/filebeat/filebeat.yml
+            subPath: filebeat.yml
+            name: filebeat-conf
+          - mountPath: /var/log/onap
+            name: {{ include "common.fullname" . }}-logs
+          - mountPath: /usr/share/filebeat/data
+            name: aai-filebeat
+
       volumes:
         - name: localtime
           hostPath:
@@ -107,7 +121,12 @@
         - name: {{ include "common.fullname" . }}-secrets
           secret:
             secretName: {{ include "common.fullname" . }}-babel-secrets
+        - name: filebeat-conf
+          configMap:
+            name: aai-filebeat
         - name: {{ include "common.fullname" . }}-logs
           emptyDir: {}
+        - name: aai-filebeat
+          emptyDir: {}
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/aai/charts/aai-cassandra/templates/volumes.yaml b/kubernetes/aai/charts/aai-cassandra/templates/volumes.yaml
index 0e1a3df..f45a450 100644
--- a/kubernetes/aai/charts/aai-cassandra/templates/volumes.yaml
+++ b/kubernetes/aai/charts/aai-cassandra/templates/volumes.yaml
@@ -5,7 +5,7 @@
 apiVersion: v1
 kind: PersistentVolume
 metadata:
-  name: {{ $root.Values.service.name }}-{{ $i }}
+  name: {{ $root.Release.Name }}-{{ $root.Values.service.name }}-{{ $i }}
   namespace: {{ $root.Release.Namespace }}
   labels:
     type: {{ $root.Values.persistence.storageType }}
@@ -22,4 +22,4 @@
     path: {{ $root.Values.persistence.mountPath }}/{{ $root.Release.Name }}/{{ $root.Values.persistence.mountSubPath }}-{{ $i }}
   persistentVolumeReclaimPolicy: {{ $root.Values.persistence.volumeReclaimPolicy }}
 {{ end }}
-#{{ end }}
\ No newline at end of file
+#{{ end }}
diff --git a/kubernetes/aai/charts/aai-champ/resources/config/dynamic/conf/champ-beans.xml b/kubernetes/aai/charts/aai-champ/resources/config/dynamic/conf/champ-beans.xml
index a271402..b3d7bc2 100644
--- a/kubernetes/aai/charts/aai-champ/resources/config/dynamic/conf/champ-beans.xml
+++ b/kubernetes/aai/charts/aai-champ/resources/config/dynamic/conf/champ-beans.xml
@@ -11,7 +11,7 @@
     <!-- Event publisher to pass to the Champ library for logging raw graph
          events (Kafka implementation). -->
     <bean id="champEventPublisher" class="org.onap.aai.event.client.KafkaEventPublisher" >
-        <constructor-arg name="hosts" value="global-kafka.{{.Release.Namespace}}:9092" />
+        <constructor-arg name="hosts" value="message-router-kafka.{{.Release.Namespace}}:9092" />
         <constructor-arg name="topic" value="champRawEvents" />
     </bean>
 
diff --git a/kubernetes/aai/charts/aai-champ/templates/deployment.yaml b/kubernetes/aai/charts/aai-champ/templates/deployment.yaml
index 9a5d0ee..0941f44 100644
--- a/kubernetes/aai/charts/aai-champ/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-champ/templates/deployment.yaml
@@ -37,7 +37,7 @@
         - --container-name
         - aai-resources
         - --container-name
-        - global-kafka
+        - message-router-kafka
         env:
         - name: NAMESPACE
           valueFrom:
@@ -49,7 +49,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/aai/charts/aai-data-router/templates/deployment.yaml b/kubernetes/aai/charts/aai-data-router/templates/deployment.yaml
index ceb9884..2d45a0b 100644
--- a/kubernetes/aai/charts/aai-data-router/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-data-router/templates/deployment.yaml
@@ -58,7 +58,7 @@
           mountPath: /logroot/
       containers:
       - name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         env:
         - name: SERVICE_BEANS
@@ -124,7 +124,7 @@
           name: {{ include "common.fullname" . }}-dynamic
       - name: {{ include "common.fullname" . }}-logs
         hostPath:
-          path: {{ .Values.persistence.mountPath }}/{{ include "common.namespace" . }}/{{ .Values.persistence.mountSubPath }}
+          path: {{ .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
       restartPolicy: {{ .Values.global.restartPolicy | default .Values.restartPolicy }}
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/aai/charts/aai-elasticsearch/templates/deployment.yaml b/kubernetes/aai/charts/aai-elasticsearch/templates/deployment.yaml
index 6792d4c..0417536 100644
--- a/kubernetes/aai/charts/aai-elasticsearch/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-elasticsearch/templates/deployment.yaml
@@ -91,6 +91,6 @@
           name: {{ include "common.fullname" . }}
       - name: elasticsearch-data
         hostPath:
-          path: {{ .Values.persistence.mountPath }}/{{ include "common.namespace" . }}/{{ .Values.persistence.mountSubPath }}
+          path: {{ .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/aai/charts/aai-gizmo/templates/deployment.yaml b/kubernetes/aai/charts/aai-gizmo/templates/deployment.yaml
index 80b5390..7b0a577 100644
--- a/kubernetes/aai/charts/aai-gizmo/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-gizmo/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ .Chart.Name }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/aai/charts/aai-gizmo/values.yaml b/kubernetes/aai/charts/aai-gizmo/values.yaml
index f6119bd..14f412e 100644
--- a/kubernetes/aai/charts/aai-gizmo/values.yaml
+++ b/kubernetes/aai/charts/aai-gizmo/values.yaml
@@ -22,7 +22,7 @@
 #################################################################
 
 # application image
-image: "onap/gizmo:1.1-STAGING-latest"
+image: onap/gizmo:1.1-STAGING-latest
 
 # application configuration
 config:
diff --git a/kubernetes/aai/charts/aai-hbase/templates/deployment.yaml b/kubernetes/aai/charts/aai-hbase/templates/deployment.yaml
index 4c92dfd..5308fa0 100644
--- a/kubernetes/aai/charts/aai-hbase/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-hbase/templates/deployment.yaml
@@ -64,7 +64,7 @@
       volumes:
       - name: hbase-data
         hostPath:
-          path: {{ .Values.persistence.mountPath }}/{{ include "common.namespace" . }}/{{ .Values.persistence.mountSubPath }}
+          path: {{ .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
       - name: localtime
         hostPath:
           path: /etc/localtime
diff --git a/kubernetes/aai/charts/aai-modelloader/resources/config/log/logback.xml b/kubernetes/aai/charts/aai-modelloader/resources/config/log/logback.xml
index fcfac84..6c2fcdc 100644
--- a/kubernetes/aai/charts/aai-modelloader/resources/config/log/logback.xml
+++ b/kubernetes/aai/charts/aai-modelloader/resources/config/log/logback.xml
@@ -1,6 +1,6 @@
 <configuration scan="true" scanPeriod="3 seconds" debug="false">
   <include resource="org/springframework/boot/logging/logback/base.xml" />
-  <property name="logDir" value="${AJSC_HOME}/logs" />
+  <property name="logDir" value="/var/log/onap" />
   <property name="componentName" value="AAI-ML"></property>
 
   <!-- default eelf log file names -->
diff --git a/kubernetes/aai/charts/aai-modelloader/templates/deployment.yaml b/kubernetes/aai/charts/aai-modelloader/templates/deployment.yaml
index 4bfa67d..7ca2a9f 100644
--- a/kubernetes/aai/charts/aai-modelloader/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-modelloader/templates/deployment.yaml
@@ -1,4 +1,4 @@
-# Copyright © 2017 Amdocs, Bell Canada
+# Copyright © 2018 Amdocs, AT&T
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -36,7 +36,7 @@
     spec:
       containers:
       - name: {{ include "common.name" . }}
-        image: {{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         env:
         - name: CONFIG_HOME
@@ -50,7 +50,7 @@
           name: {{ include "common.fullname" . }}-prop-config
         - mountPath: /opt/app/model-loader/config/auth/
           name: {{ include "common.fullname" . }}-auth-config
-        - mountPath: /logs
+        - mountPath: /var/log/onap
           name: {{ include "common.fullname" . }}-logs
         - mountPath: /opt/app/model-loader/logback.xml
           name: {{ include "common.fullname" . }}-log-conf
@@ -67,7 +67,7 @@
         - mountPath: /usr/share/filebeat/filebeat.yml
           subPath: filebeat.yml
           name: filebeat-conf
-        - mountPath: /logs
+        - mountPath: /var/log/onap
           name: {{ include "common.fullname" . }}-logs
         - mountPath: /usr/share/filebeat/data
           name: aai-filebeat
diff --git a/kubernetes/aai/charts/aai-resources/resources/config/aai_keystore b/kubernetes/aai/charts/aai-resources/resources/config/aai_keystore
deleted file mode 100644
index 1ddef0c..0000000
--- a/kubernetes/aai/charts/aai-resources/resources/config/aai_keystore
+++ /dev/null
Binary files differ
diff --git a/kubernetes/aai/charts/aai-resources/resources/config/aaiconfig.properties b/kubernetes/aai/charts/aai-resources/resources/config/aaiconfig.properties
index 0258fc2..41676cf 100644
--- a/kubernetes/aai/charts/aai-resources/resources/config/aaiconfig.properties
+++ b/kubernetes/aai/charts/aai-resources/resources/config/aaiconfig.properties
@@ -103,6 +103,8 @@
 aai.transaction.logging.get=false
 aai.transaction.logging.post=false
 
+aai.realtime.clients=SDNC,MSO,SO
+
 #timeout for crud enabled flag
 aai.crud.timeoutenabled=true
 
diff --git a/kubernetes/aai/charts/aai-resources/templates/configmap.yaml b/kubernetes/aai/charts/aai-resources/templates/configmap.yaml
index 5e371ea..373819e 100644
--- a/kubernetes/aai/charts/aai-resources/templates/configmap.yaml
+++ b/kubernetes/aai/charts/aai-resources/templates/configmap.yaml
@@ -53,12 +53,3 @@
   namespace: {{ include "common.namespace" . }}
 data:
 {{ tpl (.Files.Glob "resources/config/realm.properties").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: Secret
-metadata:
-  name: {{ include "common.fullname" . }}-auth-secret
-  namespace: {{ include "common.namespace" . }}
-type: Opaque
-data:
-{{ tpl (.Files.Glob "resources/config/aai_keystore").AsSecrets . | indent 2 }}
diff --git a/kubernetes/aai/charts/aai-resources/templates/deployment.yaml b/kubernetes/aai/charts/aai-resources/templates/deployment.yaml
index 6c65bce..c6bb14c 100644
--- a/kubernetes/aai/charts/aai-resources/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-resources/templates/deployment.yaml
@@ -34,6 +34,7 @@
         release: {{ .Release.Name }}
       name: {{ include "common.name" . }}
       annotations:
+        checksum/config: {{ include (print $.Template.BasePath "/configmap.yaml") . | sha256sum }}
         msb.onap.org/service-info: '[
           {
               "serviceName": "_aai-cloudInfrastructure",
@@ -433,7 +434,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
       - name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         env:
         - name: LOCAL_USER_ID
@@ -453,7 +454,7 @@
         - mountPath: /opt/app/aai-resources/resources/etc/appprops/aaiconfig.properties
           name: {{ include "common.fullname" . }}-aaiconfig-conf
           subPath: aaiconfig.properties
-        - mountPath: /var/log/onap
+        - mountPath: /opt/aai/logroot/AAI-RES
           name: {{ include "common.fullname" . }}-logs
         - mountPath: /opt/app/aai-resources/resources/logback.xml
           name: {{ include "common.fullname" . }}-log-conf
@@ -542,7 +543,7 @@
          name: {{ include "common.fullname" . }}-realm-configmap
       - name: {{ include "common.fullname" . }}-auth-sec
         secret:
-         secretName: {{ include "common.fullname" . }}-auth-secret
+         secretName: aai-auth-secret
       restartPolicy: {{ .Values.restartPolicy }}
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/aai/charts/aai-search-data/templates/deployment.yaml b/kubernetes/aai/charts/aai-search-data/templates/deployment.yaml
index beaee7d..c841c38 100644
--- a/kubernetes/aai/charts/aai-search-data/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-search-data/templates/deployment.yaml
@@ -36,7 +36,7 @@
     spec:
       containers:
       - name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         env:
         - name: CONFIG_HOME
diff --git a/kubernetes/aai/charts/aai-sparky-be/templates/deployment.yaml b/kubernetes/aai/charts/aai-sparky-be/templates/deployment.yaml
index 424cf11..c1b2c3c 100644
--- a/kubernetes/aai/charts/aai-sparky-be/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-sparky-be/templates/deployment.yaml
@@ -36,7 +36,7 @@
     spec:
       containers:
       - name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         env:
         - name: CONFIG_HOME
diff --git a/kubernetes/aai/charts/aai-traversal/resources/config/aai_keystore b/kubernetes/aai/charts/aai-traversal/resources/config/aai_keystore
deleted file mode 100644
index 1ddef0c..0000000
--- a/kubernetes/aai/charts/aai-traversal/resources/config/aai_keystore
+++ /dev/null
Binary files differ
diff --git a/kubernetes/aai/charts/aai-traversal/resources/config/aaiconfig.properties b/kubernetes/aai/charts/aai-traversal/resources/config/aaiconfig.properties
index 2452a1e..b095c4c 100644
--- a/kubernetes/aai/charts/aai-traversal/resources/config/aaiconfig.properties
+++ b/kubernetes/aai/charts/aai-traversal/resources/config/aaiconfig.properties
@@ -103,6 +103,8 @@
 aai.transaction.logging.get=false
 aai.transaction.logging.post=false
 
+aai.realtime.clients=SDNC,MSO,SO
+
 #timeout for traversal enabled flag
 aai.traversal.timeoutenabled=true
 
diff --git a/kubernetes/aai/charts/aai-traversal/templates/configmap.yaml b/kubernetes/aai/charts/aai-traversal/templates/configmap.yaml
index cc88444..373819e 100644
--- a/kubernetes/aai/charts/aai-traversal/templates/configmap.yaml
+++ b/kubernetes/aai/charts/aai-traversal/templates/configmap.yaml
@@ -53,12 +53,3 @@
   namespace: {{ include "common.namespace" . }}
 data:
 {{ tpl (.Files.Glob "resources/config/realm.properties").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: Secret
-metadata:
-  name: {{ include "common.fullname" . }}-auth-secret
-  namespace: {{ include "common.namespace" . }}
-type: Opaque
-data:
-{{ tpl (.Files.Glob "resources/config/aai_keystore").AsSecrets . | indent 2 }}
\ No newline at end of file
diff --git a/kubernetes/aai/charts/aai-traversal/templates/deployment.yaml b/kubernetes/aai/charts/aai-traversal/templates/deployment.yaml
index bda80a0..25cd3a9 100644
--- a/kubernetes/aai/charts/aai-traversal/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-traversal/templates/deployment.yaml
@@ -34,6 +34,7 @@
         release: {{ .Release.Name }}
       name: {{ include "common.name" . }}
       annotations:
+        checksum/config: {{ include (print $.Template.BasePath "/configmap.yaml") . | sha256sum }}
         msb.onap.org/service-info: '[
           {
               "serviceName": "_aai-generic-query",
@@ -265,7 +266,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
       - name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         env:
         - name: DISABLE_UPDATE_QUERY
@@ -287,7 +288,7 @@
         - mountPath: /opt/app/aai-traversal/resources/etc/appprops/aaiconfig.properties
           name: {{ include "common.fullname" . }}-aaiconfig-conf
           subPath: aaiconfig.properties
-        - mountPath: /var/log/onap
+        - mountPath: /opt/aai/logroot/AAI-GQ
           name: {{ include "common.fullname" . }}-logs
         - mountPath: /opt/app/aai-traversal/resources/logback.xml
           name: {{ include "common.fullname" . }}-log-conf
@@ -375,7 +376,7 @@
          name: {{ include "common.fullname" . }}-realm-configmap
       - name: {{ include "common.fullname" . }}-auth-sec
         secret:
-         secretName: {{ include "common.fullname" . }}-auth-secret
+         secretName: aai-auth-secret
       restartPolicy: {{ .Values.global.restartPolicy | default .Values.restartPolicy }}
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/aai/charts/aai-traversal/templates/job.yaml b/kubernetes/aai/charts/aai-traversal/templates/job.yaml
index b9b2501..46af004 100644
--- a/kubernetes/aai/charts/aai-traversal/templates/job.yaml
+++ b/kubernetes/aai/charts/aai-traversal/templates/job.yaml
@@ -47,7 +47,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
       - name: {{ include "common.name" . }}-job
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         command:
         - bash
@@ -99,7 +99,7 @@
           name: aai-filebeat
       - name: {{ include "common.fullname" . }}-logs
         hostPath:
-          path: {{ .Values.persistence.mountPath }}/{{ include "common.namespace" . }}/{{ .Values.persistence.mountSubPath }}-update-query
+          path: {{ .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}-update-query
       - name: {{ include "common.fullname" . }}-filebeat
         emptyDir: {}
       - name: {{ include "common.fullname" . }}-log-conf
@@ -125,7 +125,7 @@
          name: {{ include "common.fullname" . }}-realm-configmap
       - name: {{ include "common.fullname" . }}-auth-sec
         secret:
-         secretName: {{ include "common.fullname" . }}-auth-secret
+         secretName: aai-auth-secret
       restartPolicy: OnFailure
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/aai/resources/config/aai/aai_keystore b/kubernetes/aai/resources/config/aai/aai_keystore
new file mode 100644
index 0000000..16d93a7
--- /dev/null
+++ b/kubernetes/aai/resources/config/aai/aai_keystore
Binary files differ
diff --git a/kubernetes/aai/templates/configmap.yaml b/kubernetes/aai/templates/configmap.yaml
index 592e412..00d2a80 100644
--- a/kubernetes/aai/templates/configmap.yaml
+++ b/kubernetes/aai/templates/configmap.yaml
@@ -13,6 +13,25 @@
   name: aai-deployment-configmap
   namespace: {{ include "common.namespace" . }}
 data:
-{{ tpl (.Files.Glob "resources/config/haproxy/*").AsConfig . | indent 2 }}
+{{ tpl (.Files.Glob "resources/config/haproxy/haproxy.cfg").AsConfig . | indent 2 }}
+---
+apiVersion: v1
+kind: Secret
+metadata:
+  name: aai-haproxy-secret
+  namespace: {{ include "common.namespace" . }}
+type: Opaque
+data:
+{{ tpl (.Files.Glob "resources/config/haproxy/aai.pem").AsSecrets . | indent 2 }}
+# This is a shared key for both resources and traversal
+---
+apiVersion: v1
+kind: Secret
+metadata:
+  name: aai-auth-secret
+  namespace: {{ include "common.namespace" . }}
+type: Opaque
+data:
+{{ tpl (.Files.Glob "resources/config/aai/aai_keystore").AsSecrets . | indent 2 }}
 
 
diff --git a/kubernetes/aai/values.yaml b/kubernetes/aai/values.yaml
index e879818..b29f8a2 100644
--- a/kubernetes/aai/values.yaml
+++ b/kubernetes/aai/values.yaml
@@ -57,7 +57,7 @@
 
 # application image
 dockerhubRepository: registry.hub.docker.com
-image: aaionap/haproxy:1.1.0
+image: aaionap/haproxy:1.2.1
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/appc/charts/appc-cdt/templates/deployment.yaml b/kubernetes/appc/charts/appc-cdt/templates/deployment.yaml
index a250699..2226b75 100644
--- a/kubernetes/appc/charts/appc-cdt/templates/deployment.yaml
+++ b/kubernetes/appc/charts/appc-cdt/templates/deployment.yaml
@@ -19,7 +19,7 @@
       initContainers:
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/appc/resources/config/appc/opt/onap/appc/data/properties/appc.properties b/kubernetes/appc/resources/config/appc/opt/onap/appc/data/properties/appc.properties
index bf41d5b..007d0e1 100644
--- a/kubernetes/appc/resources/config/appc/opt/onap/appc/data/properties/appc.properties
+++ b/kubernetes/appc/resources/config/appc/opt/onap/appc/data/properties/appc.properties
@@ -41,13 +41,13 @@
 appc.topology.dg.version=2.0.0
 
 # TEMP - Properties that might be needed to make the AAI-APPC connection
-org.openecomp.appc.db.url.appcctl=jdbc:mysql://{{.Values.mysql.service.name}}.{{.Release.Namespace}}:3306/appcctl
-org.openecomp.appc.db.user.appcctl=appcctl
-org.openecomp.appc.db.pass.appcctl=appcctl
+org.onap.appc.db.url.appcctl=jdbc:mysql://{{.Values.mysql.service.name}}.{{.Release.Namespace}}:3306/appcctl
+org.onap.appc.db.user.appcctl=appcctl
+org.onap.appc.db.pass.appcctl=appcctl
 
-org.openecomp.appc.db.url.sdnctl=jdbc:mysql://{{.Values.mysql.service.name}}.{{.Release.Namespace}}:3306/sdnctl
-org.openecomp.appc.db.user.sdnctl=sdnctl
-org.openecomp.appc.db.pass.sdnctl=gamma
+org.onap.appc.db.url.sdnctl=jdbc:mysql://{{.Values.mysql.service.name}}.{{.Release.Namespace}}:3306/sdnctl
+org.onap.appc.db.user.sdnctl=sdnctl
+org.onap.appc.db.pass.sdnctl=gamma
 
 
 ###	                                                                	                                                                   ###
@@ -99,7 +99,7 @@
 # Port 8774 below is default port for OpenStack's Nova API Service
 test.url=http://api.appc.local/vm/9999999/test/99999999-9999-9999-9999-999999999999
 #skips hypervisor check which usually occurs during iaas-adapter-bundle startup
-org.openecomp.appc.iaas.skiphypervisorcheck=true
+org.onap.appc.iaas.skiphypervisorcheck=true
 
 # Properties from default.properties in the src/test and src/main paths of appc-asdc-listener-bundle
 appc.sdc.host=sdc-be.{{.Release.Namespace}}:8443
diff --git a/kubernetes/appc/templates/statefulset.yaml b/kubernetes/appc/templates/statefulset.yaml
index e81c50d..d2da2ec 100644
--- a/kubernetes/appc/templates/statefulset.yaml
+++ b/kubernetes/appc/templates/statefulset.yaml
@@ -37,7 +37,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           command:
           - /opt/appc/bin/startODL.sh
diff --git a/kubernetes/clamp/charts/mariadb/templates/deployment.yaml b/kubernetes/clamp/charts/mariadb/templates/deployment.yaml
index e1db655..07dcc36 100644
--- a/kubernetes/clamp/charts/mariadb/templates/deployment.yaml
+++ b/kubernetes/clamp/charts/mariadb/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ include "common.name" .  }}
-          image: {{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/clamp/templates/deployment.yaml b/kubernetes/clamp/templates/deployment.yaml
index 20beabf..4a3a0f9 100644
--- a/kubernetes/clamp/templates/deployment.yaml
+++ b/kubernetes/clamp/templates/deployment.yaml
@@ -47,7 +47,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/clamp/values.yaml b/kubernetes/clamp/values.yaml
index 8b782f9..b8f3630 100644
--- a/kubernetes/clamp/values.yaml
+++ b/kubernetes/clamp/values.yaml
@@ -28,7 +28,7 @@
 
 # application image
 repository: nexus3.onap.org:10001
-image: onap/clamp
+image: onap/clamp:2.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/cli/templates/deployment.yaml b/kubernetes/cli/templates/deployment.yaml
index f4e2f36..09e0e7f 100644
--- a/kubernetes/cli/templates/deployment.yaml
+++ b/kubernetes/cli/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
@@ -52,7 +52,7 @@
             initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
             periodSeconds: {{ .Values.readiness.periodSeconds }}
           env:
-            - name: CLI_MODE
+            - name: OPEN_CLI_MODE
               value: "{{ .Values.config.climode }}"
           resources:
 {{ toYaml .Values.resources | indent 12 }}
diff --git a/kubernetes/cli/values.yaml b/kubernetes/cli/values.yaml
index 4c95b9f..4204ee0 100644
--- a/kubernetes/cli/values.yaml
+++ b/kubernetes/cli/values.yaml
@@ -26,7 +26,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/cli:v1.1.0
+image: onap/cli:2.0-STAGING-latest
 pullPolicy: Always
 
 # application configuration
diff --git a/kubernetes/common/dgbuilder/templates/deployment.yaml b/kubernetes/common/dgbuilder/templates/deployment.yaml
index a1e9568..b9c90f2 100644
--- a/kubernetes/common/dgbuilder/templates/deployment.yaml
+++ b/kubernetes/common/dgbuilder/templates/deployment.yaml
@@ -33,7 +33,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           command: ["/bin/bash"]
           args: ["-c", "cd /opt/onap/ccsdk/dgbuilder/ && ./start.sh sdnc1.0 && wait"]
diff --git a/kubernetes/common/mariadb-galera/templates/statefulset.yaml b/kubernetes/common/mariadb-galera/templates/statefulset.yaml
index b8ba75e..ed7e1fc 100644
--- a/kubernetes/common/mariadb-galera/templates/statefulset.yaml
+++ b/kubernetes/common/mariadb-galera/templates/statefulset.yaml
@@ -35,7 +35,7 @@
       - name: {{ include "common.namespace" . }}-docker-registry-key
       containers:
         - name: {{ include "common.fullname" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy | quote}}
           env:
             - name: POD_NAMESPACE
@@ -96,7 +96,7 @@
             subPath: data
       initContainers:
         - name: mariadb-galera-prepare
-          image: {{ .Values.global.repository | default .Values.repository }}/{{ .Values.imageInit }}
+          image: "{{ include "common.repository" . }}/{{ .Values.imageInit }}"
           command: ["sh", "-c", "chown -R 27:27 /var/lib/mysql"]
           volumeMounts:
             - name: {{ include "common.fullname" . }}-data
@@ -116,4 +116,4 @@
       resources:
         requests:
           storage: {{ .Values.persistence.size | quote }}
-{{- end }}
\ No newline at end of file
+{{- end }}
diff --git a/kubernetes/common/mysql/templates/configmap.yaml b/kubernetes/common/mysql/templates/configmap.yaml
index ff127e4..d8c29fb 100644
--- a/kubernetes/common/mysql/templates/configmap.yaml
+++ b/kubernetes/common/mysql/templates/configmap.yaml
@@ -23,12 +23,14 @@
   master.cnf: |
     # Apply this config only on the master.
     [mysqld]
+    sql_mode = "NO_ENGINE_SUBSTITUTION"
     log-bin
     [localpathprefix]
     master
   slave.cnf: |
     # Apply this config only on slaves.
     [mysqld]
+    sql_mode = "NO_ENGINE_SUBSTITUTION"
     super-read-only
     [localpathprefix]
     slave
diff --git a/kubernetes/common/mysql/templates/nfs-provisoner.yaml b/kubernetes/common/mysql/templates/nfs-provisoner.yaml
index d6c6e8c..355ad38 100644
--- a/kubernetes/common/mysql/templates/nfs-provisoner.yaml
+++ b/kubernetes/common/mysql/templates/nfs-provisoner.yaml
@@ -74,5 +74,5 @@
       volumes:
         - name: export-volume
           hostPath:
-            path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}
+            path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
 {{ end }}
diff --git a/kubernetes/common/mysql/templates/pv.yaml b/kubernetes/common/mysql/templates/pv.yaml
index 1cc92ac..824dcbb 100644
--- a/kubernetes/common/mysql/templates/pv.yaml
+++ b/kubernetes/common/mysql/templates/pv.yaml
@@ -34,5 +34,5 @@
   storageClassName: "{{ include "common.fullname" . }}-data"
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
 {{- end -}}
diff --git a/kubernetes/common/postgres/templates/pv.yaml b/kubernetes/common/postgres/templates/pv.yaml
index e08c934..144a3f7 100644
--- a/kubernetes/common/postgres/templates/pv.yaml
+++ b/kubernetes/common/postgres/templates/pv.yaml
@@ -33,7 +33,7 @@
   storageClassName: "{{ include "common.fullname" . }}-data"
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}0
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}0
 ---
 kind: PersistentVolume
 apiVersion: v1
@@ -54,5 +54,5 @@
   storageClassName: "{{ include "common.fullname" . }}-data"
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}1
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}1
 {{- end -}}
diff --git a/kubernetes/common/postgres/templates/statefulset.yaml b/kubernetes/common/postgres/templates/statefulset.yaml
index e42e9eb..c3f8674 100644
--- a/kubernetes/common/postgres/templates/statefulset.yaml
+++ b/kubernetes/common/postgres/templates/statefulset.yaml
@@ -126,7 +126,7 @@
           path: /etc/localtime
       - name: {{ include "common.fullname" . }}-init
         hostPath:
-          path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountInitPath }}
+          path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountInitPath }}
       - name: {{ include "common.fullname" . }}-backup
         emptyDir: {}
 #{{ if not .Values.persistence.enabled }}
diff --git a/kubernetes/consul/charts/consul-server/templates/deployment.yaml b/kubernetes/consul/charts/consul-server/templates/deployment.yaml
index 12403e7..8272d3c 100644
--- a/kubernetes/consul/charts/consul-server/templates/deployment.yaml
+++ b/kubernetes/consul/charts/consul-server/templates/deployment.yaml
@@ -34,6 +34,8 @@
         release: {{ .Release.Name }}
       name: {{ include "common.name" . }}
     spec:
+      imagePullSecrets:
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
       containers:
       - image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         command: ["/usr/local/bin/docker-entrypoint.sh"]
diff --git a/kubernetes/consul/resources/config/consul-agent-config/cli-health-check.json b/kubernetes/consul/resources/config/consul-agent-config/cli-health-check.json
new file mode 100644
index 0000000..81e55cb
--- /dev/null
+++ b/kubernetes/consul/resources/config/consul-agent-config/cli-health-check.json
@@ -0,0 +1,15 @@
+{
+  "service": {
+    "name": "Health Check: ONAP CLI",
+    "checks": [
+      {
+        "id": "cli",
+        "name": "CLI Health Check",
+        "http": "http://cli.{{include "common.namespace" .}}:8080",
+        "method": "GET",
+        "interval": "3600s",
+        "timeout": "1s"
+      }
+    ]
+  }
+}
diff --git a/kubernetes/consul/resources/config/consul-agent-config/scripts/mr-kafka-health.sh b/kubernetes/consul/resources/config/consul-agent-config/scripts/mr-kafka-health.sh
index 6630117..fd45875 100755
--- a/kubernetes/consul/resources/config/consul-agent-config/scripts/mr-kafka-health.sh
+++ b/kubernetes/consul/resources/config/consul-agent-config/scripts/mr-kafka-health.sh
@@ -1,4 +1,4 @@
-kafkapod=$(/consul/bin/kubectl -n {{ include "common.namespace" . }} get pod | grep -o "message-router-global-kafka-[^[:space:]]*")
+kafkapod=$(/consul/bin/kubectl -n {{ include "common.namespace" . }} get pod | grep -o "message-router-kafka-[^[:space:]]*")
 if [ -n "$kafkapod" ]; then
    if /consul/bin/kubectl -n {{ include "common.namespace" . }} exec -it $kafkapod -- ps ef | grep -i kafka; then
       echo Success. Kafka process is running. 2>&1
diff --git a/kubernetes/consul/templates/deployment.yaml b/kubernetes/consul/templates/deployment.yaml
index 646922b..8fd09b7 100644
--- a/kubernetes/consul/templates/deployment.yaml
+++ b/kubernetes/consul/templates/deployment.yaml
@@ -34,6 +34,8 @@
         release: {{ .Release.Name }}
       name: {{ include "common.name" . }}
     spec:
+      imagePullSecrets:
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
       containers:
       - image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         command:
diff --git a/kubernetes/consul/values.yaml b/kubernetes/consul/values.yaml
index 6ff0390..0b5f7fe 100644
--- a/kubernetes/consul/values.yaml
+++ b/kubernetes/consul/values.yaml
@@ -26,8 +26,8 @@
 # Application configuration defaults.
 #################################################################
 # application image
-repository: oomk8s
-image: consul:1.0.0
+repository: docker.io
+image: oomk8s/consul:1.0.0
 pullPolicy: Always
 
 #subchart name
diff --git a/kubernetes/dcaegen2/charts/dcae-bootstrap/templates/job.yaml b/kubernetes/dcaegen2/charts/dcae-bootstrap/templates/job.yaml
index 6229af4..02909f7 100644
--- a/kubernetes/dcaegen2/charts/dcae-bootstrap/templates/job.yaml
+++ b/kubernetes/dcaegen2/charts/dcae-bootstrap/templates/job.yaml
@@ -61,7 +61,7 @@
               fieldPath: metadata.namespace
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           volumeMounts:
             - mountPath: /inputs
diff --git a/kubernetes/dcaegen2/charts/dcae-bootstrap/values.yaml b/kubernetes/dcaegen2/charts/dcae-bootstrap/values.yaml
index 6df05b1..e8927eb 100644
--- a/kubernetes/dcaegen2/charts/dcae-bootstrap/values.yaml
+++ b/kubernetes/dcaegen2/charts/dcae-bootstrap/values.yaml
@@ -61,7 +61,7 @@
 
 # application image
 repository: nexus3.onap.org:10001
-image: onap/org.onap.dcaegen2.deployments.k8s-bootstrap-container:1.1.8
+image: onap/org.onap.dcaegen2.deployments.k8s-bootstrap-container:latest
 
 # DCAE component images to be deployed via Cloudify Manager
 # Use to override default setting in blueprints
diff --git a/kubernetes/dcaegen2/charts/dcae-cloudify-manager/templates/deployment.yaml b/kubernetes/dcaegen2/charts/dcae-cloudify-manager/templates/deployment.yaml
index 76c83af..acda520 100644
--- a/kubernetes/dcaegen2/charts/dcae-cloudify-manager/templates/deployment.yaml
+++ b/kubernetes/dcaegen2/charts/dcae-cloudify-manager/templates/deployment.yaml
@@ -36,7 +36,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/dcaegen2/charts/dcae-cloudify-manager/values.yaml b/kubernetes/dcaegen2/charts/dcae-cloudify-manager/values.yaml
index 53f7670..28b96e7 100644
--- a/kubernetes/dcaegen2/charts/dcae-cloudify-manager/values.yaml
+++ b/kubernetes/dcaegen2/charts/dcae-cloudify-manager/values.yaml
@@ -41,7 +41,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/org.onap.dcaegen2.deployments.cm-container:1.3.0
+image: onap/org.onap.dcaegen2.deployments.cm-container:latest
 pullPolicy: Always
 
 # probe configuration parameters
diff --git a/kubernetes/dcaegen2/charts/dcae-healthcheck/templates/deployment.yaml b/kubernetes/dcaegen2/charts/dcae-healthcheck/templates/deployment.yaml
index 2166ca9..463504c 100644
--- a/kubernetes/dcaegen2/charts/dcae-healthcheck/templates/deployment.yaml
+++ b/kubernetes/dcaegen2/charts/dcae-healthcheck/templates/deployment.yaml
@@ -36,7 +36,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/dcaegen2/charts/dcae-redis/templates/pv.yaml b/kubernetes/dcaegen2/charts/dcae-redis/templates/pv.yaml
index 2d7e25d..5573179 100644
--- a/kubernetes/dcaegen2/charts/dcae-redis/templates/pv.yaml
+++ b/kubernetes/dcaegen2/charts/dcae-redis/templates/pv.yaml
@@ -33,7 +33,7 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}0
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}0
 ---
 kind: PersistentVolume
 apiVersion: v1
@@ -54,7 +54,7 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}1
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}1
 ---
 kind: PersistentVolume
 apiVersion: v1
@@ -75,7 +75,7 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}2
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}2
 ---
 kind: PersistentVolume
 apiVersion: v1
@@ -96,7 +96,7 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}3
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}3
 ---
 kind: PersistentVolume
 apiVersion: v1
@@ -117,7 +117,7 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}4
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}4
 ---
 kind: PersistentVolume
 apiVersion: v1
@@ -138,7 +138,7 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}5
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}5
 ---
 kind: PersistentVolume
 apiVersion: v1
@@ -159,7 +159,7 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}6
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}6
 ---
 kind: PersistentVolume
 apiVersion: v1
@@ -180,7 +180,7 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}7
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}7
 ---
 kind: PersistentVolume
 apiVersion: v1
@@ -201,7 +201,7 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}8
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}8
 ---
 kind: PersistentVolume
 apiVersion: v1
@@ -222,6 +222,6 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}9
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}9
 
 {{- end -}}
diff --git a/kubernetes/dcaegen2/charts/dcae-redis/templates/statefulset.yaml b/kubernetes/dcaegen2/charts/dcae-redis/templates/statefulset.yaml
index 63d921a..f72e540 100644
--- a/kubernetes/dcaegen2/charts/dcae-redis/templates/statefulset.yaml
+++ b/kubernetes/dcaegen2/charts/dcae-redis/templates/statefulset.yaml
@@ -35,7 +35,7 @@
       initContainers:
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           command:
           - /bin/sh
diff --git a/kubernetes/dcaegen2/charts/dcae-redis/values.yaml b/kubernetes/dcaegen2/charts/dcae-redis/values.yaml
index 9a5eacd..bcf1750 100644
--- a/kubernetes/dcaegen2/charts/dcae-redis/values.yaml
+++ b/kubernetes/dcaegen2/charts/dcae-redis/values.yaml
@@ -29,7 +29,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/org.onap.dcaegen2.deployments.redis-cluster-container:1.0.0
+image: onap/org.onap.dcaegen2.deployments.redis-cluster-container:latest
 pullPolicy: Always
 
 # application configuration
diff --git a/kubernetes/dmaap/Chart.yaml b/kubernetes/dmaap/Chart.yaml
index a83b50b..b18e59d 100644
--- a/kubernetes/dmaap/Chart.yaml
+++ b/kubernetes/dmaap/Chart.yaml
@@ -13,6 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: a Helm chart to deploy ONAP DMaaP componetns in Kubernetes
+description: ONAP DMaaP components
 name: dmaap
 version: 2.0.0
diff --git a/kubernetes/dmaap/Makefile b/kubernetes/dmaap/Makefile
index 36ca4f5..d80a921 100644
--- a/kubernetes/dmaap/Makefile
+++ b/kubernetes/dmaap/Makefile
@@ -12,5 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-make-dmaap:
-	cd charts && helm dep up dmaap-bus-controller
+make-dmaap: make-bus-controller make-message-router
+
+make-bus-controller:
+	cd charts && helm dep up dmaap-bus-controller && helm lint dmaap-bus-controller
+
+make-message-router:
+	cd charts && helm dep up message-router && helm lint message-router
+
+clean:
+	@find . -type f -name '*.tgz' -delete
diff --git a/kubernetes/dmaap/README.md b/kubernetes/dmaap/README.md
index e185fdc..ad81b2f 100644
--- a/kubernetes/dmaap/README.md
+++ b/kubernetes/dmaap/README.md
@@ -1,11 +1,25 @@
+# Copyright © 2018  AT&T Intellectual Property.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 # Helm Chart for ONAP DMaaP Applications
 
 ONAP includes the following Kubernetes services:
 
 1) message-router - a message bus for applications
-2) dmaap-prov - an API to provision DMaaP resources
+2) dbc-api - an API to provision DMaaP resources
 
 # Service Dependencies
 
 message-router depends on AAF
-dmaap-prov depends on AAF and Postgresql.  NOTE: until Postgresql is available as a common service in ONAP, this chart deploys a private instance based on kubernetes/stable chart
+dbc-api depends on AAF and Postgresql.
\ No newline at end of file
diff --git a/kubernetes/dmaap/charts/dmaap-bus-controller/templates/NOTES.txt b/kubernetes/dmaap/charts/dmaap-bus-controller/templates/NOTES.txt
index fbab5a3..254c6bf 100644
--- a/kubernetes/dmaap/charts/dmaap-bus-controller/templates/NOTES.txt
+++ b/kubernetes/dmaap/charts/dmaap-bus-controller/templates/NOTES.txt
@@ -1,3 +1,17 @@
+# Copyright © 2018  AT&T Intellectual Property.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 1. Get the application URL by running these commands:
 {{- if .Values.ingress.enabled }}
 {{- range .Values.ingress.hosts }}
diff --git a/kubernetes/dmaap/charts/dmaap-bus-controller/templates/deployment.yaml b/kubernetes/dmaap/charts/dmaap-bus-controller/templates/deployment.yaml
index 2c38792..32d6fe0 100644
--- a/kubernetes/dmaap/charts/dmaap-bus-controller/templates/deployment.yaml
+++ b/kubernetes/dmaap/charts/dmaap-bus-controller/templates/deployment.yaml
@@ -47,7 +47,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image.buscontrollerImage }}:{{ .Values.image.buscontrollerVersion }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/dmaap/charts/dmaap-bus-controller/values.yaml b/kubernetes/dmaap/charts/dmaap-bus-controller/values.yaml
index 3acb490..2b4067d 100644
--- a/kubernetes/dmaap/charts/dmaap-bus-controller/values.yaml
+++ b/kubernetes/dmaap/charts/dmaap-bus-controller/values.yaml
@@ -32,14 +32,12 @@
 # application images
 repository: nexus3.onap.org:10001
 
-image:
-  buscontrollerImage: onap/dmaap/buscontroller
-  buscontrollerVersion: 1.0.8
+image: onap/dmaap/buscontroller:1.0.8
 
 
 # application configuration
-dmaapMessageRouterService: dmaap
-aafURL: https://onap-aaf:8905/proxy/
+dmaapMessageRouterService: message-router
+aafURL: https://aaf-authz/
 topicMgrUser: m23456@dmaapbc.onap.org
 topicMgrPwd: onapdemo
 adminUser: m12345@dmaapbc.onap.org
@@ -63,32 +61,38 @@
 
 
 service:
-  type: ClusterIP
+  type: NodePort
   name: dmaap-bc
+  portName: dmaap-bc
+  portName2: dmaap-bc
   externalPort: 8080
   internalPort: 8080
   externalPort2: 8443
   internalPort2: 8443
+  nodePort: 41
+  nodePort2: 42
 
 
 # application configuration override for postgres
 postgres:
-  nameOverride: dbcl-db
+  nameOverride: dbc-pg
   service:
-    name: dbcl-postgres
-    name2: dbcl-pg-primary
-    name3: dbcl-pg-replica
+    name: dbc-postgres
+    name2: dbc-pg-primary
+    name3: dbc-pg-replica
   container:
     name:
-      primary: dbcl-pg-primary
-      replica: dbcl-pg-replica
+      primary: dbc-pg-primary
+      replica: dbc-pg-replica
   config:
     pgUserName: dmaap_admin
     pgDatabase: dmaap
     pgPrimaryPassword: onapdemodb
     pgUserPassword: onapdemodb
     pgRootPassword: onapdemodb
-
+  persistence:
+    mountSubPath: dbc/data
+    mountInitPath: dbc
 
 ingress:
   enabled: false
diff --git a/kubernetes/message-router/.helmignore b/kubernetes/dmaap/charts/message-router/.helmignore
similarity index 100%
rename from kubernetes/message-router/.helmignore
rename to kubernetes/dmaap/charts/message-router/.helmignore
diff --git a/kubernetes/message-router/Chart.yaml b/kubernetes/dmaap/charts/message-router/Chart.yaml
similarity index 97%
rename from kubernetes/message-router/Chart.yaml
rename to kubernetes/dmaap/charts/message-router/Chart.yaml
index b3a7491..dd7371c 100644
--- a/kubernetes/message-router/Chart.yaml
+++ b/kubernetes/dmaap/charts/message-router/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-appVersion: "1.0"
 description: ONAP Message Router
 name: message-router
 version: 2.0.0
diff --git a/kubernetes/message-router/charts/kafka/.helmignore b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/.helmignore
similarity index 100%
rename from kubernetes/message-router/charts/kafka/.helmignore
rename to kubernetes/dmaap/charts/message-router/charts/message-router-kafka/.helmignore
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/Chart.yaml
similarity index 88%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/dmaap/charts/message-router/charts/message-router-kafka/Chart.yaml
index dd999e5..1457fa8 100644
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/Chart.yaml
@@ -13,7 +13,7 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
+description: ONAP Message Router Kafka Service
+name: message-router-kafka
 version: 2.0.0
 
diff --git a/kubernetes/message-router/charts/kafka/templates/NOTES.txt b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/NOTES.txt
similarity index 69%
copy from kubernetes/message-router/charts/kafka/templates/NOTES.txt
copy to kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/NOTES.txt
index c60c745..f6e6e93 100644
--- a/kubernetes/message-router/charts/kafka/templates/NOTES.txt
+++ b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/NOTES.txt
@@ -1,3 +1,17 @@
+# Copyright © 2018  AT&T Intellectual Property.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 1. Get the application URL by running these commands:
 {{- if .Values.ingress.enabled }}
 {{- range .Values.ingress.hosts }}
diff --git a/kubernetes/message-router/charts/kafka/templates/deployment.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/deployment.yaml
similarity index 96%
rename from kubernetes/message-router/charts/kafka/templates/deployment.yaml
rename to kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/deployment.yaml
index a4e13cd..25ab210 100644
--- a/kubernetes/message-router/charts/kafka/templates/deployment.yaml
+++ b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/deployment.yaml
@@ -46,7 +46,7 @@
         - /root/ready.py
         args:
         - --container-name
-        - {{ .Values.zookeeper.nameOverride }}
+        - {{ .Values.zookeeper.name }}
         env:
         - name: NAMESPACE
           valueFrom:
@@ -78,7 +78,7 @@
           periodSeconds: {{ .Values.readiness.periodSeconds }}
         env:
         - name: KAFKA_ZOOKEEPER_CONNECT
-          value: "{{.Values.zookeeper.nameOverride}}:{{.Values.config.zookeeperPort}}"
+          value: "{{.Values.zookeeper.name}}:{{.Values.zookeeper.port}}"
         - name: KAFKA_ADVERTISED_HOST_NAME
           value: "{{ include "common.servicename" .  }}"
         - name: KAFKA_BROKER_ID
diff --git a/kubernetes/message-router/charts/kafka/templates/pv.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/pv.yaml
similarity index 93%
rename from kubernetes/message-router/charts/kafka/templates/pv.yaml
rename to kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/pv.yaml
index 8be3d4c..da117f4 100644
--- a/kubernetes/message-router/charts/kafka/templates/pv.yaml
+++ b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/pv.yaml
@@ -33,5 +33,5 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
 {{- end -}}
diff --git a/kubernetes/message-router/charts/kafka/templates/pvc.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/pvc.yaml
similarity index 100%
rename from kubernetes/message-router/charts/kafka/templates/pvc.yaml
rename to kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/pvc.yaml
diff --git a/kubernetes/message-router/charts/kafka/templates/service.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/service.yaml
similarity index 95%
rename from kubernetes/message-router/charts/kafka/templates/service.yaml
rename to kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/service.yaml
index c57d190..117a8a9 100644
--- a/kubernetes/message-router/charts/kafka/templates/service.yaml
+++ b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/templates/service.yaml
@@ -26,7 +26,7 @@
   ports:
     - port: {{ .Values.service.externalPort }}
       targetPort: {{ .Values.service.internalPort }}
-      name: {{ .Values.service.name }}
+      name: {{ .Values.service.portName }}
   selector:
     app: {{ include "common.name" . }}
     release: {{ .Release.Name }}
diff --git a/kubernetes/message-router/charts/kafka/values.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/values.yaml
similarity index 95%
rename from kubernetes/message-router/charts/kafka/values.yaml
rename to kubernetes/dmaap/charts/message-router/charts/message-router-kafka/values.yaml
index 7675ee8..0e7c2b7 100644
--- a/kubernetes/message-router/charts/kafka/values.yaml
+++ b/kubernetes/dmaap/charts/message-router/charts/message-router-kafka/values.yaml
@@ -31,18 +31,18 @@
 #################################################################
 # application image
 repository: docker.io
-image: wurstmeister/kafka:latest
+image: wurstmeister/kafka:1.1.0
 pullPolicy: Always
 
 zookeeper:
-  nameOverride: zookeeper
+  name: message-router-zookeeper
+  port: 2181
 
 # flag to enable debugging - application support required
 debugEnabled: false
 
 # application configuration
-config:
-  zookeeperPort: 2181
+config: {}
 
 # default number of instances
 replicaCount: 1
@@ -88,7 +88,8 @@
 
 service:
   type: NodePort
-  name: global-kafka
+  name: message-router-kafka
+  portName: message-router-kafka
   internalPort: 9092
   externalPort: 9092
 
diff --git a/kubernetes/message-router/charts/zookeeper/.helmignore b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/.helmignore
similarity index 100%
rename from kubernetes/message-router/charts/zookeeper/.helmignore
rename to kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/.helmignore
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/Chart.yaml
similarity index 87%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/Chart.yaml
index dd999e5..49ac35b 100644
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/Chart.yaml
@@ -13,7 +13,7 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
+description: ONAP Dmaap Message Router Zookeeper Service
+name: message-router-zookeeper
 version: 2.0.0
 
diff --git a/kubernetes/message-router/charts/kafka/templates/NOTES.txt b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/NOTES.txt
similarity index 69%
copy from kubernetes/message-router/charts/kafka/templates/NOTES.txt
copy to kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/NOTES.txt
index c60c745..f6e6e93 100644
--- a/kubernetes/message-router/charts/kafka/templates/NOTES.txt
+++ b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/NOTES.txt
@@ -1,3 +1,17 @@
+# Copyright © 2018  AT&T Intellectual Property.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 1. Get the application URL by running these commands:
 {{- if .Values.ingress.enabled }}
 {{- range .Values.ingress.hosts }}
diff --git a/kubernetes/message-router/charts/zookeeper/templates/deployment.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/deployment.yaml
similarity index 100%
rename from kubernetes/message-router/charts/zookeeper/templates/deployment.yaml
rename to kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/deployment.yaml
diff --git a/kubernetes/message-router/charts/kafka/templates/pv.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/pv.yaml
similarity index 93%
copy from kubernetes/message-router/charts/kafka/templates/pv.yaml
copy to kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/pv.yaml
index 8be3d4c..da117f4 100644
--- a/kubernetes/message-router/charts/kafka/templates/pv.yaml
+++ b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/pv.yaml
@@ -33,5 +33,5 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
 {{- end -}}
diff --git a/kubernetes/message-router/charts/zookeeper/templates/pvc.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/pvc.yaml
similarity index 100%
rename from kubernetes/message-router/charts/zookeeper/templates/pvc.yaml
rename to kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/pvc.yaml
diff --git a/kubernetes/message-router/charts/zookeeper/templates/service.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/service.yaml
similarity index 100%
rename from kubernetes/message-router/charts/zookeeper/templates/service.yaml
rename to kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/templates/service.yaml
diff --git a/kubernetes/message-router/charts/zookeeper/values.yaml b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/values.yaml
similarity index 97%
rename from kubernetes/message-router/charts/zookeeper/values.yaml
rename to kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/values.yaml
index 8a41970..517a7c9 100644
--- a/kubernetes/message-router/charts/zookeeper/values.yaml
+++ b/kubernetes/dmaap/charts/message-router/charts/message-router-zookeeper/values.yaml
@@ -84,7 +84,8 @@
 
 service:
   type: NodePort
-  name: zookeeper
+  name: message-router-zookeeper
+  portName: message-router-zookeeper
   internalPort: 2181
 
 ingress:
diff --git a/kubernetes/message-router/requirements.yaml b/kubernetes/dmaap/charts/message-router/requirements.yaml
similarity index 100%
rename from kubernetes/message-router/requirements.yaml
rename to kubernetes/dmaap/charts/message-router/requirements.yaml
diff --git a/kubernetes/message-router/resources/config/dmaap/MsgRtrApi.properties b/kubernetes/dmaap/charts/message-router/resources/config/dmaap/MsgRtrApi.properties
similarity index 92%
rename from kubernetes/message-router/resources/config/dmaap/MsgRtrApi.properties
rename to kubernetes/dmaap/charts/message-router/resources/config/dmaap/MsgRtrApi.properties
index ed3999d..4015e94 100755
--- a/kubernetes/message-router/resources/config/dmaap/MsgRtrApi.properties
+++ b/kubernetes/dmaap/charts/message-router/resources/config/dmaap/MsgRtrApi.properties
@@ -29,11 +29,7 @@
 ##
 ##	Both Cambria and Kafka make use of Zookeeper.
 ##
-config.zk.servers={{.Values.zookeeper.nameOverride}}:{{.Values.config.zookeeperPort}}
-#config.zk.servers=172.17.0.1:2181
-#dmaap.onap-message-router:2181
-#10.208.128.229:2181
-#config.zk.root=/fe3c/cambria/config
+config.zk.servers={{.Values.zookeeper.name}}:{{.Values.zookeeper.port}}
 
 
 ###############################################################################
@@ -43,11 +39,7 @@
 ##	Items below are passed through to Kafka's producer and consumer
 ##	configurations (after removing "kafka.")
 ##	if you want to change request.required.acks it can take this one value
-#kafka.metadata.broker.list=localhost:9092,localhost:9093
-kafka.metadata.broker.list={{.Values.kafka.nameOverride}}:{{.Values.config.kafkaPort}}
-#kafka.metadata.broker.list=172.17.0.1:9092
-#dmaap.onap-message-router:9092
-#10.208.128.229:9092
+kafka.metadata.broker.list={{.Values.kafka.name}}:{{.Values.kafka.port}}
 ##kafka.request.required.acks=-1
 #kafka.client.zookeeper=${config.zk.servers}
 consumer.timeout.ms=100
diff --git a/kubernetes/message-router/resources/config/dmaap/cadi.properties b/kubernetes/dmaap/charts/message-router/resources/config/dmaap/cadi.properties
similarity index 100%
rename from kubernetes/message-router/resources/config/dmaap/cadi.properties
rename to kubernetes/dmaap/charts/message-router/resources/config/dmaap/cadi.properties
diff --git a/kubernetes/message-router/resources/config/dmaap/mykey b/kubernetes/dmaap/charts/message-router/resources/config/dmaap/mykey
similarity index 100%
rename from kubernetes/message-router/resources/config/dmaap/mykey
rename to kubernetes/dmaap/charts/message-router/resources/config/dmaap/mykey
diff --git a/kubernetes/message-router/charts/kafka/templates/NOTES.txt b/kubernetes/dmaap/charts/message-router/templates/NOTES.txt
similarity index 69%
copy from kubernetes/message-router/charts/kafka/templates/NOTES.txt
copy to kubernetes/dmaap/charts/message-router/templates/NOTES.txt
index c60c745..f6e6e93 100644
--- a/kubernetes/message-router/charts/kafka/templates/NOTES.txt
+++ b/kubernetes/dmaap/charts/message-router/templates/NOTES.txt
@@ -1,3 +1,17 @@
+# Copyright © 2018  AT&T Intellectual Property.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 1. Get the application URL by running these commands:
 {{- if .Values.ingress.enabled }}
 {{- range .Values.ingress.hosts }}
diff --git a/kubernetes/dmaap/charts/message-router/templates/configmap.yaml b/kubernetes/dmaap/charts/message-router/templates/configmap.yaml
new file mode 100644
index 0000000..9816bd9
--- /dev/null
+++ b/kubernetes/dmaap/charts/message-router/templates/configmap.yaml
@@ -0,0 +1,29 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ include "common.fullname" . }}-msgrtrapi-prop-configmap
+  namespace: {{ include "common.namespace" . }}
+data:
+{{ tpl (.Files.Glob "resources/config/dmaap/MsgRtrApi.properties").AsConfig . | indent 2 }}
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ include "common.fullname" . }}-cadi-prop-configmap
+  namespace: {{ include "common.namespace" . }}
+data:
+{{ tpl (.Files.Glob "resources/config/dmaap/cadi.properties").AsConfig . | indent 2 }}
diff --git a/kubernetes/message-router/templates/deployment.yaml b/kubernetes/dmaap/charts/message-router/templates/deployment.yaml
similarity index 97%
rename from kubernetes/message-router/templates/deployment.yaml
rename to kubernetes/dmaap/charts/message-router/templates/deployment.yaml
index ed3c4eb..379fc24 100644
--- a/kubernetes/message-router/templates/deployment.yaml
+++ b/kubernetes/dmaap/charts/message-router/templates/deployment.yaml
@@ -34,9 +34,9 @@
         - /root/ready.py
         args:
         - --container-name
-        - {{ .Values.kafka.nameOverride }}
+        - {{ .Values.kafka.name }}
         - --container-name
-        - {{ .Values.zookeeper.nameOverride }}
+        - {{ .Values.zookeeper.name }}
         env:
         - name: NAMESPACE
           valueFrom:
diff --git a/kubernetes/message-router/templates/secrets.yaml b/kubernetes/dmaap/charts/message-router/templates/secrets.yaml
similarity index 100%
rename from kubernetes/message-router/templates/secrets.yaml
rename to kubernetes/dmaap/charts/message-router/templates/secrets.yaml
diff --git a/kubernetes/message-router/templates/service.yaml b/kubernetes/dmaap/charts/message-router/templates/service.yaml
similarity index 100%
rename from kubernetes/message-router/templates/service.yaml
rename to kubernetes/dmaap/charts/message-router/templates/service.yaml
diff --git a/kubernetes/message-router/values.yaml b/kubernetes/dmaap/charts/message-router/values.yaml
similarity index 95%
rename from kubernetes/message-router/values.yaml
rename to kubernetes/dmaap/charts/message-router/values.yaml
index 181368d..c69fe53 100644
--- a/kubernetes/message-router/values.yaml
+++ b/kubernetes/dmaap/charts/message-router/values.yaml
@@ -31,20 +31,18 @@
 image: onap/dmaap/dmaap-mr:1.1.4
 pullPolicy: Always
 
-nameOverride: dmaap
-
 kafka:
-  nameOverride: global-kafka
+  name: message-router-kafka
+  port: 9092
 zookeeper:
-  nameOverride: zookeeper
+  name: message-router-zookeeper
+  port: 2181
 
 # flag to enable debugging - application support required
 debugEnabled: false
 
 # application configuration
-config:
-  zookeeperPort: 2181
-  kafkaPort: 9092
+config: {}
 
 # default number of instances
 replicaCount: 1
diff --git a/kubernetes/dmaap/values.yaml b/kubernetes/dmaap/values.yaml
index 76f0383..6cf26ff 100644
--- a/kubernetes/dmaap/values.yaml
+++ b/kubernetes/dmaap/values.yaml
@@ -22,6 +22,3 @@
   readinessImage: readiness-check:2.0.0
   loggingRepository: docker.elastic.co
   loggingImage: beats/filebeat:5.5.0
-  postgresDatabase: dmaap
-  postgresUser: dmaap_admin
-  postgresPassword: onapdemodb
\ No newline at end of file
diff --git a/kubernetes/esr/charts/esr-gui/templates/deployment.yaml b/kubernetes/esr/charts/esr-gui/templates/deployment.yaml
index 747df22..e1b27bb 100644
--- a/kubernetes/esr/charts/esr-gui/templates/deployment.yaml
+++ b/kubernetes/esr/charts/esr-gui/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: {{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/esr/charts/esr-gui/values.yaml b/kubernetes/esr/charts/esr-gui/values.yaml
index f501399..2ebea31 100644
--- a/kubernetes/esr/charts/esr-gui/values.yaml
+++ b/kubernetes/esr/charts/esr-gui/values.yaml
@@ -24,7 +24,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/aai/esr-gui:v1.0.0
+image: onap/aai/esr-gui:1.1.0-SNAPSHOT
 pullPolicy: Always
 msbaddr: msb-iag.{{ include "common.namespace" . }}:80
 
diff --git a/kubernetes/esr/templates/deployment.yaml b/kubernetes/esr/templates/deployment.yaml
index c2322d3..3f15df8 100644
--- a/kubernetes/esr/templates/deployment.yaml
+++ b/kubernetes/esr/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ .Chart.Name }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/esr/values.yaml b/kubernetes/esr/values.yaml
index 27f4df9..47afd0c 100644
--- a/kubernetes/esr/values.yaml
+++ b/kubernetes/esr/values.yaml
@@ -28,7 +28,7 @@
 
 # application image
 repository: nexus3.onap.org:10001
-image: onap/aai/esr-server:v1.0.0
+image: onap/aai/esr-server:1.1.0-SNAPSHOT
 pullPolicy: Always
 msbaddr: msb-iag.{{ include "common.namespace" . }}:80
 
diff --git a/kubernetes/log/charts/log-elasticsearch/templates/deployment.yaml b/kubernetes/log/charts/log-elasticsearch/templates/deployment.yaml
index fdfc614..c4491b9 100644
--- a/kubernetes/log/charts/log-elasticsearch/templates/deployment.yaml
+++ b/kubernetes/log/charts/log-elasticsearch/templates/deployment.yaml
@@ -112,6 +112,6 @@
             claimName: {{ include "common.fullname" . }}
         - name: {{ include "common.fullname" . }}-logs
           hostPath:
-            path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPathLogs }}
+            path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPathLogs }}
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/log/charts/log-elasticsearch/templates/pv.yaml b/kubernetes/log/charts/log-elasticsearch/templates/pv.yaml
index dba12d4..31230a9 100644
--- a/kubernetes/log/charts/log-elasticsearch/templates/pv.yaml
+++ b/kubernetes/log/charts/log-elasticsearch/templates/pv.yaml
@@ -17,5 +17,5 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
 {{- end -}}
diff --git a/kubernetes/message-router/charts/zookeeper/templates/NOTES.txt b/kubernetes/message-router/charts/zookeeper/templates/NOTES.txt
deleted file mode 100644
index c60c745..0000000
--- a/kubernetes/message-router/charts/zookeeper/templates/NOTES.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-1. Get the application URL by running these commands:
-{{- if .Values.ingress.enabled }}
-{{- range .Values.ingress.hosts }}
-  http://{{ . }}
-{{- end }}
-{{- else if contains "NodePort" .Values.service.type }}
-  export NODE_PORT=$(kubectl get --namespace {{ include "common.namespace" . }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ include "common.name" . }})
-  export NODE_IP=$(kubectl get nodes --namespace {{ include "common.namespace" . }} -o jsonpath="{.items[0].status.addresses[0].address}")
-  echo http://$NODE_IP:$NODE_PORT
-{{- else if contains "LoadBalancer" .Values.service.type }}
-     NOTE: It may take a few minutes for the LoadBalancer IP to be available.
-           You can watch the status of by running 'kubectl get svc -w {{ include "common.name" . }}'
-  export SERVICE_IP=$(kubectl get svc --namespace {{ include "common.namespace" . }} {{ include "common.name" . }} -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
-  echo http://$SERVICE_IP:{{ .Values.service.externalPort }}
-{{- else if contains "ClusterIP" .Values.service.type }}
-  export POD_NAME=$(kubectl get pods --namespace {{ include "common.namespace" . }} -l "app={{ include "common.name" . }},release={{ .Release.Name }}" -o jsonpath="{.items[0].metadata.name}")
-  echo "Visit http://127.0.0.1:8080 to use your application"
-  kubectl port-forward $POD_NAME 8080:{{ .Values.service.internalPort }}
-{{- end }}
diff --git a/kubernetes/message-router/charts/zookeeper/templates/pv.yaml b/kubernetes/message-router/charts/zookeeper/templates/pv.yaml
deleted file mode 100644
index 8be3d4c..0000000
--- a/kubernetes/message-router/charts/zookeeper/templates/pv.yaml
+++ /dev/null
@@ -1,37 +0,0 @@
-{{/*
-# Copyright © 2017 Amdocs, Bell Canada
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-*/}}
-
-{{- if and .Values.persistence.enabled (not .Values.persistence.existingClaim) -}}
-kind: PersistentVolume
-apiVersion: v1
-metadata:
-  name: {{ include "common.fullname" . }}
-  namespace: {{ include "common.namespace" . }}
-  labels:
-    app: {{ include "common.name" . }}
-    chart: "{{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}"
-    release: "{{ .Release.Name }}"
-    heritage: "{{ .Release.Service }}"
-    name: {{ include "common.fullname" . }}
-spec:
-  capacity:
-    storage: {{ .Values.persistence.size }}
-  accessModes:
-    - {{ .Values.persistence.accessMode }}
-  persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
-  hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}
-{{- end -}}
diff --git a/kubernetes/message-router/templates/NOTES.txt b/kubernetes/message-router/templates/NOTES.txt
deleted file mode 100644
index c60c745..0000000
--- a/kubernetes/message-router/templates/NOTES.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-1. Get the application URL by running these commands:
-{{- if .Values.ingress.enabled }}
-{{- range .Values.ingress.hosts }}
-  http://{{ . }}
-{{- end }}
-{{- else if contains "NodePort" .Values.service.type }}
-  export NODE_PORT=$(kubectl get --namespace {{ include "common.namespace" . }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ include "common.name" . }})
-  export NODE_IP=$(kubectl get nodes --namespace {{ include "common.namespace" . }} -o jsonpath="{.items[0].status.addresses[0].address}")
-  echo http://$NODE_IP:$NODE_PORT
-{{- else if contains "LoadBalancer" .Values.service.type }}
-     NOTE: It may take a few minutes for the LoadBalancer IP to be available.
-           You can watch the status of by running 'kubectl get svc -w {{ include "common.name" . }}'
-  export SERVICE_IP=$(kubectl get svc --namespace {{ include "common.namespace" . }} {{ include "common.name" . }} -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
-  echo http://$SERVICE_IP:{{ .Values.service.externalPort }}
-{{- else if contains "ClusterIP" .Values.service.type }}
-  export POD_NAME=$(kubectl get pods --namespace {{ include "common.namespace" . }} -l "app={{ include "common.name" . }},release={{ .Release.Name }}" -o jsonpath="{.items[0].metadata.name}")
-  echo "Visit http://127.0.0.1:8080 to use your application"
-  kubectl port-forward $POD_NAME 8080:{{ .Values.service.internalPort }}
-{{- end }}
diff --git a/kubernetes/message-router/templates/configmap.yaml b/kubernetes/message-router/templates/configmap.yaml
deleted file mode 100644
index 911d2e9..0000000
--- a/kubernetes/message-router/templates/configmap.yaml
+++ /dev/null
@@ -1,15 +0,0 @@
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: {{ include "common.fullname" . }}-msgrtrapi-prop-configmap
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/config/dmaap/MsgRtrApi.properties").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: {{ include "common.fullname" . }}-cadi-prop-configmap
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/config/dmaap/cadi.properties").AsConfig . | indent 2 }}
diff --git a/kubernetes/msb/charts/kube2msb/templates/deployment.yaml b/kubernetes/msb/charts/kube2msb/templates/deployment.yaml
index ad38750..4313871 100644
--- a/kubernetes/msb/charts/kube2msb/templates/deployment.yaml
+++ b/kubernetes/msb/charts/kube2msb/templates/deployment.yaml
@@ -33,7 +33,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           env:
           - name: KUBE_MASTER_URL
diff --git a/kubernetes/msb/charts/msb-discovery/templates/deployment.yaml b/kubernetes/msb/charts/msb-discovery/templates/deployment.yaml
index b266005..aec03b0 100644
--- a/kubernetes/msb/charts/msb-discovery/templates/deployment.yaml
+++ b/kubernetes/msb/charts/msb-discovery/templates/deployment.yaml
@@ -33,7 +33,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/msb/charts/msb-discovery/values.yaml b/kubernetes/msb/charts/msb-discovery/values.yaml
index 357a7eb..04f3b46 100644
--- a/kubernetes/msb/charts/msb-discovery/values.yaml
+++ b/kubernetes/msb/charts/msb-discovery/values.yaml
@@ -12,7 +12,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/msb/msb_discovery:1.1.0-SNAPSHOT-latest
+image: onap/msb/msb_discovery:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # application configuration
diff --git a/kubernetes/msb/charts/msb-eag/templates/deployment.yaml b/kubernetes/msb/charts/msb-eag/templates/deployment.yaml
index 7ca8a8e..26ee388 100644
--- a/kubernetes/msb/charts/msb-eag/templates/deployment.yaml
+++ b/kubernetes/msb/charts/msb-eag/templates/deployment.yaml
@@ -33,7 +33,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/msb/charts/msb-eag/values.yaml b/kubernetes/msb/charts/msb-eag/values.yaml
index 0540d0d..f3b8833 100644
--- a/kubernetes/msb/charts/msb-eag/values.yaml
+++ b/kubernetes/msb/charts/msb-eag/values.yaml
@@ -12,7 +12,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/msb/msb_apigateway:1.1.0-SNAPSHOT-latest
+image: onap/msb/msb_apigateway:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # application configuration
diff --git a/kubernetes/msb/charts/msb-iag/templates/deployment.yaml b/kubernetes/msb/charts/msb-iag/templates/deployment.yaml
index 7ca8a8e..26ee388 100644
--- a/kubernetes/msb/charts/msb-iag/templates/deployment.yaml
+++ b/kubernetes/msb/charts/msb-iag/templates/deployment.yaml
@@ -33,7 +33,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/msb/charts/msb-iag/values.yaml b/kubernetes/msb/charts/msb-iag/values.yaml
index a659dae..dc7e7cb 100644
--- a/kubernetes/msb/charts/msb-iag/values.yaml
+++ b/kubernetes/msb/charts/msb-iag/values.yaml
@@ -12,7 +12,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/msb/msb_apigateway:1.1.0-SNAPSHOT-latest
+image: onap/msb/msb_apigateway:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # application configuration
diff --git a/kubernetes/multicloud/charts/multicloud-ocata/templates/deployment.yaml b/kubernetes/multicloud/charts/multicloud-ocata/templates/deployment.yaml
index db8bcdc..0106a79 100644
--- a/kubernetes/multicloud/charts/multicloud-ocata/templates/deployment.yaml
+++ b/kubernetes/multicloud/charts/multicloud-ocata/templates/deployment.yaml
@@ -59,7 +59,7 @@
        - mountPath: /opt/ocata/ocata/pub/config/log.yml
          name: ocata-logconfig
          subPath: log.yml
-       image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+       image: "{{ include "common.repository" . }}/{{ .Values.image }}"
        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
        ports:
        - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/multicloud/charts/multicloud-ocata/values.yaml b/kubernetes/multicloud/charts/multicloud-ocata/values.yaml
index a1f72ea..6d46d94 100644
--- a/kubernetes/multicloud/charts/multicloud-ocata/values.yaml
+++ b/kubernetes/multicloud/charts/multicloud-ocata/values.yaml
@@ -24,7 +24,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/multicloud/openstack-ocata:latest
+image: onap/multicloud/openstack-ocata:1.1.2-SNAPSHOT
 pullPolicy: Always
 
 # application configuration
diff --git a/kubernetes/multicloud/charts/multicloud-vio/templates/deployment.yaml b/kubernetes/multicloud/charts/multicloud-vio/templates/deployment.yaml
index 903963b..fa96466 100644
--- a/kubernetes/multicloud/charts/multicloud-vio/templates/deployment.yaml
+++ b/kubernetes/multicloud/charts/multicloud-vio/templates/deployment.yaml
@@ -59,7 +59,7 @@
        - mountPath: /opt/vio/vio/pub/config/log.yml
          name: vio-logconfig
          subPath: log.yml
-       image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+       image: "{{ include "common.repository" . }}/{{ .Values.image }}"
        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
        ports:
        - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/multicloud/charts/multicloud-vio/values.yaml b/kubernetes/multicloud/charts/multicloud-vio/values.yaml
index 4fea235..29885fa 100644
--- a/kubernetes/multicloud/charts/multicloud-vio/values.yaml
+++ b/kubernetes/multicloud/charts/multicloud-vio/values.yaml
@@ -24,7 +24,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/multicloud/vio:latest
+image: onap/multicloud/vio:1.1.2-STAGING
 pullPolicy: Always
 
 # application configuration
diff --git a/kubernetes/multicloud/charts/multicloud-windriver/templates/deployment.yaml b/kubernetes/multicloud/charts/multicloud-windriver/templates/deployment.yaml
index 02a78bb..75969ba 100644
--- a/kubernetes/multicloud/charts/multicloud-windriver/templates/deployment.yaml
+++ b/kubernetes/multicloud/charts/multicloud-windriver/templates/deployment.yaml
@@ -59,7 +59,7 @@
        - mountPath: /opt/windriver/titanium_cloud/pub/config/log.yml
          name: windriver-logconfig
          subPath: log.yml
-       image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+       image: "{{ include "common.repository" . }}/{{ .Values.image }}"
        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
        ports:
        - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/multicloud/charts/multicloud-windriver/values.yaml b/kubernetes/multicloud/charts/multicloud-windriver/values.yaml
index 919289c..3bcb1aa 100644
--- a/kubernetes/multicloud/charts/multicloud-windriver/values.yaml
+++ b/kubernetes/multicloud/charts/multicloud-windriver/values.yaml
@@ -24,7 +24,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/multicloud/openstack-windriver:latest
+image: onap/multicloud/openstack-windriver:1.1.2-SNAPSHOT
 pullPolicy: Always
 
 # application configuration
diff --git a/kubernetes/multicloud/templates/deployment.yaml b/kubernetes/multicloud/templates/deployment.yaml
index 3a0671c..5ae5fd9 100644
--- a/kubernetes/multicloud/templates/deployment.yaml
+++ b/kubernetes/multicloud/templates/deployment.yaml
@@ -52,7 +52,7 @@
          value: "{{ .Values.config.aai.username }}"
        - name: AAI_PASSWORD
          value: "{{ .Values.config.aai.password }}"
-       image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+       image: "{{ include "common.repository" . }}/{{ .Values.image }}"
        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
        name: {{ include "common.name" . }}
        volumeMounts:
diff --git a/kubernetes/multicloud/values.yaml b/kubernetes/multicloud/values.yaml
index 8a30d1a..4c217df 100644
--- a/kubernetes/multicloud/values.yaml
+++ b/kubernetes/multicloud/values.yaml
@@ -26,7 +26,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/multicloud/framework:latest
+image: onap/multicloud/framework:1.1.2-STAGING
 pullPolicy: Always
 
 # application configuration
diff --git a/kubernetes/onap/requirements.yaml b/kubernetes/onap/requirements.yaml
index 8c9c128..03ee94d 100644
--- a/kubernetes/onap/requirements.yaml
+++ b/kubernetes/onap/requirements.yaml
@@ -60,10 +60,6 @@
     version: ~2.0.0
     repository: '@local'
     condition: log.enabled
-  - name: message-router
-    version: ~2.0.0
-    repository: '@local'
-    condition: message-router.enabled
   - name: mock
     version: ~0.1.0
     repository: '@local'
@@ -84,6 +80,10 @@
     version: ~2.0.0
     repository: '@local'
     condition: portal.enabled
+  - name: oof
+    version: ~2.0.0
+    repository: '@local'
+    condition: oof.enabled
   - name: robot
     version: ~2.0.0
     repository: '@local'
diff --git a/kubernetes/onap/resources/environments/dev.yaml b/kubernetes/onap/resources/environments/dev.yaml
index 651cb91..4379f64 100644
--- a/kubernetes/onap/resources/environments/dev.yaml
+++ b/kubernetes/onap/resources/environments/dev.yaml
@@ -65,14 +65,16 @@
   enabled: false
 dcaegen2:
   enabled: false
+dmaap:
+  enabled: false
 esr:
   enabled: false
 log:
   enabled: false
-message-router:
-  enabled: false
 mock:
   enabled: false
+oof:
+  enabled: false
 msb:
   enabled: false
 multicloud:
@@ -128,4 +130,4 @@
 vid:
   enabled: false
 vnfsdk:
-  enabled: false
\ No newline at end of file
+  enabled: false
diff --git a/kubernetes/onap/resources/environments/disable-allcharts.yaml b/kubernetes/onap/resources/environments/disable-allcharts.yaml
index 7e27a31..819cc7a 100644
--- a/kubernetes/onap/resources/environments/disable-allcharts.yaml
+++ b/kubernetes/onap/resources/environments/disable-allcharts.yaml
@@ -39,18 +39,20 @@
   enabled: false
 dcaegen2:
   enabled: false
+dmaap:
+  enabled: false
 esr:
   enabled: false
 log:
   enabled: false
-message-router:
-  enabled: false
 mock:
   enabled: false
 msb:
   enabled: false
 multicloud:
   enabled: false
+oof:
+  enabled: false
 policy:
   enabled: false
 portal:
@@ -70,4 +72,4 @@
 vid:
   enabled: false
 vnfsdk:
-  enabled: false
\ No newline at end of file
+  enabled: false
diff --git a/kubernetes/onap/values.yaml b/kubernetes/onap/values.yaml
index 6107f3d..28b33fc 100644
--- a/kubernetes/onap/values.yaml
+++ b/kubernetes/onap/values.yaml
@@ -74,6 +74,8 @@
   enabled: true
 dcaegen2:
   enabled: true
+dmaap:
+  enabled: true
 esr:
   enabled: true
 log:
@@ -82,6 +84,8 @@
   enabled: true
 mock:
   enabled: true
+oof:
+  enabled: true
 msb:
   enabled: true
 multicloud:
diff --git a/kubernetes/message-router/charts/kafka/Chart.yaml b/kubernetes/oof/Chart.yaml
old mode 100644
new mode 100755
similarity index 91%
rename from kubernetes/message-router/charts/kafka/Chart.yaml
rename to kubernetes/oof/Chart.yaml
index b26f91a..36d3125
--- a/kubernetes/message-router/charts/kafka/Chart.yaml
+++ b/kubernetes/oof/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Global Kafka Service
-name: kafka
+description: ONAP Optimization Framework
+name: oof
 version: 2.0.0
-
diff --git a/kubernetes/message-router/charts/kafka/Chart.yaml b/kubernetes/oof/Makefile
similarity index 81%
copy from kubernetes/message-router/charts/kafka/Chart.yaml
copy to kubernetes/oof/Makefile
index b26f91a..72f97ef 100644
--- a/kubernetes/message-router/charts/kafka/Chart.yaml
+++ b/kubernetes/oof/Makefile
@@ -1,4 +1,4 @@
-# Copyright © 2017 Amdocs, Bell Canada
+# Copyright © 2017 Amdocs, AT&T, Bell Canada, VMware
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,8 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-apiVersion: v1
-description: ONAP Global Kafka Service
-name: kafka
-version: 2.0.0
-
+make-has:
+	cd charts && helm dep up oof-has
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/Chart.yaml
old mode 100644
new mode 100755
similarity index 90%
rename from kubernetes/message-router/charts/zookeeper/Chart.yaml
rename to kubernetes/oof/charts/oof-has/Chart.yaml
index dd999e5..a1ec5ac
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
+description: ONAP Homing and Allocation Service
+name: oof-has
 version: 2.0.0
-
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-api/Chart.yaml
old mode 100644
new mode 100755
similarity index 89%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-api/Chart.yaml
index dd999e5..01d4eec
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-api/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
+description: ONAP Homing and Allocation Servicei - API
+name: oof-has-api
 version: 2.0.0
-
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-api/templates/NOTES.txt b/kubernetes/oof/charts/oof-has/charts/oof-has-api/templates/NOTES.txt
new file mode 100755
index 0000000..b3622e3
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-api/templates/NOTES.txt
@@ -0,0 +1,33 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+1. Get the application URL by running these commands:
+{{- if .Values.ingress.enabled }}
+{{- range .Values.ingress.hosts }}
+  http://{{ . }}
+{{- end }}
+{{- else if contains "NodePort" .Values.service.type }}
+  export NODE_PORT=$(kubectl get --namespace {{ include "common.namespace" . }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ include "common.fullname" . }})
+  export NODE_IP=$(kubectl get nodes --namespace {{ include "common.namespace" . }} -o jsonpath="{.items[0].status.addresses[0].address}")
+  echo http://$NODE_IP:$NODE_PORT
+{{- else if contains "LoadBalancer" .Values.service.type }}
+     NOTE: It may take a few minutes for the LoadBalancer IP to be available.
+           You can watch the status of by running 'kubectl get svc -w {{ include "common.fullname" . }}'
+  export SERVICE_IP=$(kubectl get svc --namespace {{ include "common.namespace" . }} {{ include "common.fullname" . }} -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
+  echo http://$SERVICE_IP:{{ .Values.service.externalPort }}
+{{- else if contains "ClusterIP" .Values.service.type }}
+  export POD_NAME=$(kubectl get pods --namespace {{ include "common.namespace" . }} -l "app={{ include "common.fullname" . }},release={{ .Release.Name }}" -o jsonpath="{.items[0].metadata.name}")
+  echo "Visit http://127.0.0.1:8080 to use your application"
+  kubectl port-forward $POD_NAME 8080:{{ .Values.service.internalPort }}
+{{- end }}
diff --git a/kubernetes/message-router/templates/deployment.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-api/templates/deployment.yaml
old mode 100644
new mode 100755
similarity index 62%
copy from kubernetes/message-router/templates/deployment.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-api/templates/deployment.yaml
index ed3c4eb..2709371
--- a/kubernetes/message-router/templates/deployment.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-api/templates/deployment.yaml
@@ -11,6 +11,7 @@
 # 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.
+
 apiVersion: extensions/v1beta1
 kind: Deployment
 metadata:
@@ -34,9 +35,7 @@
         - /root/ready.py
         args:
         - --container-name
-        - {{ .Values.kafka.nameOverride }}
-        - --container-name
-        - {{ .Values.zookeeper.nameOverride }}
+        - oof-has-music
         env:
         - name: NAMESPACE
           valueFrom:
@@ -48,48 +47,63 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.global.image.optf_has }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+          command:
+          - python
+          args:
+          - /usr/local/bin/conductor-api
+          - --port={{ .Values.service.internalPort }}
+          - --
+          - --config-file=/usr/local/bin/conductor.conf
           ports:
-          - containerPort: {{ .Values.service.externalPort }}
-          - containerPort: {{ .Values.service.externalPort2 }}
-          {{- if eq .Values.liveness.enabled true }}
+          - containerPort: {{ .Values.service.internalPort }}
+          # disable liveness probe when breakpoints set in debugger
+          # so K8s doesn't restart unresponsive container
+          {{- if .Values.liveness.enabled }}
           livenessProbe:
             tcpSocket:
-              port: {{ .Values.service.externalPort }}
+              port: {{ .Values.service.internalPort }}
             initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
             periodSeconds: {{ .Values.liveness.periodSeconds }}
           {{ end -}}
           readinessProbe:
             tcpSocket:
-              port: {{ .Values.service.externalPort }}
+              port: {{ .Values.service.internalPort }}
             initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
             periodSeconds: {{ .Values.readiness.periodSeconds }}
+          env:
           volumeMounts:
           - mountPath: /etc/localtime
             name: localtime
             readOnly: true
-          - mountPath: /appl/dmaapMR1/bundleconfig/etc/appprops/MsgRtrApi.properties
-            subPath: MsgRtrApi.properties
-            name: appprops
-          - mountPath: /appl/dmaapMR1/etc/cadi.properties
-            subPath: cadi.properties
-            name: cadi
-          - mountPath: /appl/dmaapMR1/etc/keyfile
-            subPath: mykey
-            name: mykey
+          - mountPath: /usr/local/bin/conductor.conf
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: conductor.conf
+          - mountPath: /usr/local/bin/log.conf
+            name: {{ .Values.global.commonConfigPrefix  }}-config
+            subPath: log.conf
+          resources:
+{{ toYaml .Values.resources | indent 12 }}
+        {{- if .Values.nodeSelector }}
+        nodeSelector:
+{{ toYaml .Values.nodeSelector | indent 10 }}
+        {{- end -}}
+        {{- if .Values.affinity }}
+        affinity:
+{{ toYaml .Values.affinity | indent 10 }}
+        {{- end }}
       volumes:
         - name: localtime
           hostPath:
             path: /etc/localtime
-        - name: appprops
+        - name: {{ .Values.global.commonConfigPrefix }}-config
           configMap:
-            name: {{ include "common.fullname" . }}-msgrtrapi-prop-configmap
-        - name: cadi
-          configMap:
-            name: {{ include "common.fullname" . }}-cadi-prop-configmap
-        - name: mykey
-          secret:
-            secretName: {{ include "common.fullname" . }}-secret
+            name: {{ .Values.global.commonConfigPrefix  }}-configmap
+            items:
+            - key: conductor.conf
+              path: conductor.conf
+            - key: log.conf
+              path: log.conf
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/message-router/charts/kafka/templates/service.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-api/templates/service.yaml
old mode 100644
new mode 100755
similarity index 71%
copy from kubernetes/message-router/charts/kafka/templates/service.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-api/templates/service.yaml
index c57d190..58d1ab6
--- a/kubernetes/message-router/charts/kafka/templates/service.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-api/templates/service.yaml
@@ -15,18 +15,26 @@
 apiVersion: v1
 kind: Service
 metadata:
-  name: {{ .Values.service.name }}
+  name: {{ include "common.servicename" . }}
   namespace: {{ include "common.namespace" . }}
   labels:
     app: {{ include "common.name" . }}
     chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
     release: {{ .Release.Name }}
     heritage: {{ .Release.Service }}
+  annotations:
 spec:
+  type: {{ .Values.service.type }}
   ports:
+    {{if eq .Values.service.type "NodePort" -}}
+    - port: {{ .Values.service.externalPort }}
+      nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort }}
+      name: {{ .Values.service.portName }}
+    {{- else -}}
     - port: {{ .Values.service.externalPort }}
       targetPort: {{ .Values.service.internalPort }}
-      name: {{ .Values.service.name }}
+      name: {{ .Values.service.portName }}
+    {{- end}}
   selector:
     app: {{ include "common.name" . }}
     release: {{ .Release.Name }}
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-api/values.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-api/values.yaml
new file mode 100755
index 0000000..6114de3
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-api/values.yaml
@@ -0,0 +1,37 @@
+# Copyright © 2017 Amdocs, AT&T, Bell Canada, VMware
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+service:
+  type: NodePort
+  name: oof-has-api
+  externalPort: 8091
+  internalPort: 8091
+  nodePort: 75
+  portName: oof-has-api
+ingress:
+  enabled: false
+replicaCount: 1
+nodeSelector: {}
+affinity: {}
+# probe configuration parameters
+liveness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+  # necessary to disable liveness probe when setting breakpoints
+  # in debugger so K8s doesn't restart unresponsive container
+  enabled: true
+readiness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+resources: {}
diff --git a/kubernetes/message-router/.helmignore b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/.helmignore
similarity index 100%
copy from kubernetes/message-router/.helmignore
copy to kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/.helmignore
diff --git a/kubernetes/message-router/charts/kafka/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/Chart.yaml
similarity index 91%
copy from kubernetes/message-router/charts/kafka/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/Chart.yaml
index b26f91a..501bd99 100644
--- a/kubernetes/message-router/charts/kafka/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Global Kafka Service
-name: kafka
+description: OOF-HAS Cassandra
+name: oof-has-cassandra
 version: 2.0.0
-
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/resources/config/cassandra/docker-entrypoint-initdb.d/zzz_conductor.cql b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/resources/config/cassandra/docker-entrypoint-initdb.d/zzz_conductor.cql
new file mode 100644
index 0000000..c2593eb
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/resources/config/cassandra/docker-entrypoint-initdb.d/zzz_conductor.cql
@@ -0,0 +1,90 @@
+# Copyright © 2017 Amdocs, AT&T, Bell Canada, VMware
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+CREATE KEYSPACE conductor WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}  AND durable_writes = true;
+
+CREATE TABLE conductor.plans (
+    id text PRIMARY KEY,
+    created bigint,
+    message text,
+    name text,
+    recommend_max int,
+    reservation_counter int,
+    reservation_owner text,
+    solution text,
+    solver_counter int,
+    solver_owner text,
+    status text,
+    template text,
+    timeout int,
+    translation text,
+    translation_counter int,
+    translation_owner text,
+    updated bigint,
+    vector_ts text
+);
+
+CREATE INDEX conductor_plans_index ON conductor.plans(status);
+
+CREATE KEYSPACE conductor_rpc WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}  AND durable_writes = true;
+
+CREATE TABLE conductor_rpc.controller (
+    id text PRIMARY KEY,
+    action text,
+    args text,
+    created bigint,
+    ctxt text,
+    failure text,
+    method text,
+    owner text,
+    response text,
+    status text,
+    updated bigint,
+    vector_ts text
+);
+
+CREATE TABLE conductor_rpc.data (
+    id text PRIMARY KEY,
+    action text,
+    args text,
+    created bigint,
+    ctxt text,
+    failure text,
+    method text,
+    owner text,
+    response text,
+    status text,
+    updated bigint,
+    vector_ts text
+);
+
+INSERT INTO admin.keyspace_master (
+uuid, application_name, is_aaf, is_api, keyspace_name, password,username)
+VALUES ( now(), 'conductor', False, True, 'conductor', 'c0nduct0r', 'conductor');
+
+INSERT INTO admin.keyspace_master (
+uuid, application_name, is_aaf, is_api, keyspace_name, password, username)
+VALUES( now(), 'conductor', False, True, 'conductor_rpc', 'c0nduct0r', 'conductor');
+
+CREATE ROLE IF NOT EXISTS conductor WITH PASSWORD = 'c0nduct0r' AND LOGIN = true;
+
+GRANT ALL PERMISSIONS on KEYSPACE conductor to 'conductor';
+
+GRANT ALL PERMISSIONS on KEYSPACE conductor_rpc to 'conductor';
+
+INSERT INTO conductor.plans (id, created, message, name, recommend_max, solution, status, template,timeout, translation,updated) VALUES('healthcheck',1479482603641,'','foo',1,'{"healthcheck": " healthcheck"}','solved','{"healthcheck": "healthcheck"}',3600,'{"healthcheck": "healthcheck"}',1484324150629);
+
+
+
diff --git a/kubernetes/message-router/charts/kafka/templates/NOTES.txt b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/NOTES.txt
similarity index 70%
rename from kubernetes/message-router/charts/kafka/templates/NOTES.txt
rename to kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/NOTES.txt
index c60c745..8f907c0 100644
--- a/kubernetes/message-router/charts/kafka/templates/NOTES.txt
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/NOTES.txt
@@ -1,3 +1,17 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 1. Get the application URL by running these commands:
 {{- if .Values.ingress.enabled }}
 {{- range .Values.ingress.hosts }}
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/configmap.yaml
similarity index 70%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/configmap.yaml
index dd999e5..e0fec18 100644
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/configmap.yaml
@@ -13,7 +13,10 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
-version: 2.0.0
+kind: ConfigMap
+metadata:
+  name: {{ include "common.fullname" . }}-docker-entry-initd
+  namespace: {{ include "common.namespace" . }}
+data:
+{{ tpl (.Files.Glob "resources/config/cassandra/docker-entrypoint-initdb.d/*").AsConfig . | indent 2 }}
 
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/deployment.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/deployment.yaml
new file mode 100644
index 0000000..63f85c6
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/deployment.yaml
@@ -0,0 +1,104 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: {{ include "common.fullname" . }}
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+spec:
+  replicas: {{ .Values.replicaCount }}
+  template:
+    metadata:
+      labels:
+        app: {{ include "common.name" . }}
+        release: {{ .Release.Name }}
+    spec:
+      containers:
+      - name: {{ include "common.name" . }}
+        image: {{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}
+        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+        ports:
+        - containerPort: {{ .Values.service.internalPort }}
+        - containerPort: {{ .Values.service.internalPort2 }}
+        - containerPort: {{ .Values.service.internalPort3 }}
+        - containerPort: {{ .Values.service.internalPort4 }}
+        - containerPort: {{ .Values.service.internalPort5 }}
+        {{ if eq .Values.liveness.enabled true }}
+        livenessProbe:
+          exec:
+            command:
+            - /bin/bash
+            - -c
+            - nodetool status | grep $POD_IP | awk '$1!="UN" { exit 1; }'
+          initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
+          periodSeconds: {{ .Values.liveness.periodSeconds }}
+        {{ end }}
+        readinessProbe:
+          exec:
+            command:
+            - /bin/bash
+            - -c
+            - nodetool status | grep $POD_IP | awk '$1!="UN" { exit 1; }'
+          initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
+          periodSeconds: {{ .Values.readiness.periodSeconds }}
+        env:
+          - name: CASSUSER
+            value: "{{ .Values.config.cassandraUsername }}"
+          - name: CASSPASS
+            value: "{{ .Values.config.cassandraPassword }}"
+          - name: POD_IP
+            valueFrom:
+              fieldRef:
+                fieldPath: status.podIP
+        volumeMounts:
+        - mountPath: /etc/localtime
+          name: localtime
+          readOnly: true
+        - name: cassandra-docker-entrypoint-initdb
+          mountPath: /docker-entrypoint-initdb.d/zzz_conductor.cql
+          subPath: zzz_conductor.cql
+        - name: {{ include "common.fullname" . }}-data
+          mountPath: /var/lib/cassandra/data
+        resources:
+{{ toYaml .Values.resources | indent 12 }}
+      {{- if .Values.nodeSelector }}
+      nodeSelector:
+{{ toYaml .Values.nodeSelector | indent 10 }}
+      {{- end -}}
+      {{- if .Values.affinity }}
+      affinity:
+{{ toYaml .Values.affinity | indent 10 }}
+      {{- end }}
+      volumes:
+        - name: localtime
+          hostPath:
+            path: /etc/localtime
+        - name: cassandra-docker-entrypoint-initdb
+          configMap:
+            name: {{ include "common.fullname" . }}-docker-entry-initd
+      {{- if .Values.persistence.enabled }}
+        - name: {{ include "common.fullname" . }}-data
+          persistentVolumeClaim:
+            claimName: {{ include "common.fullname" . }}
+      {{- else }}
+          emptyDir: {}
+      {{- end }}
+      imagePullSecrets:
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/message-router/charts/kafka/templates/pv.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/pv.yaml
similarity index 90%
copy from kubernetes/message-router/charts/kafka/templates/pv.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/pv.yaml
index 8be3d4c..184728f 100644
--- a/kubernetes/message-router/charts/kafka/templates/pv.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/pv.yaml
@@ -28,10 +28,10 @@
     name: {{ include "common.fullname" . }}
 spec:
   capacity:
-    storage: {{ .Values.persistence.size }}
+    storage: {{ .Values.persistence.size}}
   accessModes:
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
 {{- end -}}
diff --git a/kubernetes/message-router/charts/kafka/templates/pvc.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/pvc.yaml
similarity index 100%
copy from kubernetes/message-router/charts/kafka/templates/pvc.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/pvc.yaml
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/service.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/service.yaml
new file mode 100644
index 0000000..1217431
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/templates/service.yaml
@@ -0,0 +1,69 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ include "common.servicename" . }}
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+spec:
+  type: {{ .Values.service.type }}
+  ports:
+    {{if eq .Values.service.type "NodePort" -}}
+    - port: {{ .Values.service.externalPort }}
+      targetPort: {{ .Values.service.internalPort }}
+      nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort }}
+      name: {{ .Values.service.portName }}
+    - port: {{ .Values.service.externalPort2 }}
+      targetPort: {{ .Values.service.internalPort2 }}
+      nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort2 }}
+      name: {{ .Values.service.portName }}2
+    - port: {{ .Values.service.externalPort3 }}
+      targetPort: {{ .Values.service.internalPort3 }}
+      nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort3 }}
+      name: {{ .Values.service.portName }}3
+    - port: {{ .Values.service.externalPort4 }}
+      targetPort: {{ .Values.service.internalPort4 }}
+      nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort4 }}
+      name: {{ .Values.service.portName }}4
+    - port: {{ .Values.service.externalPort5 }}
+      targetPort: {{ .Values.service.internalPort5 }}
+      nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort5 }}
+      name: {{ .Values.service.portName }}5
+
+    {{- else -}}
+    - port: {{ .Values.service.externalPort }}
+      targetPort: {{ .Values.service.internalPort }}
+      name: {{ .Values.service.portName }}
+    - port: {{ .Values.service.externalPort2 }}
+      targetPort: {{ .Values.service.internalPort2 }}
+      name: {{ .Values.service.portName }}2
+    - port: {{ .Values.service.externalPort3 }}
+      targetPort: {{ .Values.service.internalPort3 }}
+      name: {{ .Values.service.portName }}3
+    - port: {{ .Values.service.externalPort4 }}
+      targetPort: {{ .Values.service.internalPort4 }}
+      name: {{ .Values.service.portName }}4
+    - port: {{ .Values.service.externalPort5 }}
+      targetPort: {{ .Values.service.internalPort5 }}
+      name: {{ .Values.service.portName }}5
+    {{- end}}
+  selector:
+    app: {{ include "common.name" . }}
+    release: {{ .Release.Name }}
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/values.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/values.yaml
new file mode 100644
index 0000000..9bb5af3
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-cassandra/values.yaml
@@ -0,0 +1,93 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Default values for mariadb.
+# This is a YAML-formatted file.
+# Declare variables to be passed into your templates.
+global: # global defaults
+  nodePortPrefix: 302
+  repositorySecret: eyJuZXh1czMub25hcC5vcmc6MTAwMDEiOnsidXNlcm5hbWUiOiJkb2NrZXIiLCJwYXNzd29yZCI6ImRvY2tlciIsImVtYWlsIjoiQCIsImF1dGgiOiJaRzlqYTJWeU9tUnZZMnRsY2c9PSJ9fQ==
+  persistence: {}
+
+
+# application image
+repository: nexus3.onap.org:10001
+image: onap/music/cassandra_music:3.0.0
+pullPolicy: Always
+
+# application configuration
+config:
+  cassandraUsername: root
+  cassandraPassword: Aa123456
+
+# default number of instances
+replicaCount: 1
+
+nodeSelector: {}
+
+affinity: {}
+
+# probe configuration parameters
+liveness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+  # necessary to disable liveness probe when setting breakpoints
+  # in debugger so K8s doesn't restart unresponsive container
+  enabled: true
+
+readiness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+
+## Persist data to a persitent volume
+persistence:
+  enabled: true
+
+  ## A manually managed Persistent Volume and Claim
+  ## Requires persistence.enabled: true
+  ## If defined, PVC must be created manually before volume will be bound
+  # existingClaim:
+  volumeReclaimPolicy: Retain
+
+  ## database data Persistent Volume Storage Class
+  ## If defined, storageClassName: <storageClass>
+  ## If set to "-", storageClassName: "", which disables dynamic provisioning
+  ## If undefined (the default) or set to null, no storageClassName spec is
+  ##   set, choosing the default provisioner.  (gp2 on AWS, standard on
+  ##   GKE, AWS & OpenStack)
+  ##
+  # storageClass: "-"
+  accessMode: ReadWriteMany
+  size: 2Gi
+  mountPath: /dockerdata-nfs
+  mountSubPath: oof/cassandra/data
+service:
+  type: ClusterIP
+  name: oof-has-cassandra
+  portName: oof-has-cassandra
+  externalPort: 9160
+  internalPort: 9160
+  externalPort2: 7000
+  internalPort2: 7000
+  externalPort3: 7001
+  internalPort3: 7001
+  externalPort4: 7199
+  internalPort4: 7199
+  externalPort5: 9042
+  internalPort5: 9042
+
+ingress:
+  enabled: false
+
+resources: {}
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-controller/Chart.yaml
old mode 100644
new mode 100755
similarity index 87%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-controller/Chart.yaml
index dd999e5..d0e124e
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-controller/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
+description: ONAP Homing and Allocation Sservice - Controller
+name: oof-has-controller
 version: 2.0.0
-
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-controller/templates/deployment.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-controller/templates/deployment.yaml
new file mode 100755
index 0000000..5535f90
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-controller/templates/deployment.yaml
@@ -0,0 +1,114 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: {{ include "common.fullname" . }}
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+spec:
+  replicas: {{ .Values.replicaCount }}
+  template:
+    metadata:
+      labels:
+        app: {{ include "common.name" . }}
+        release: {{ .Release.Name }}
+    spec:
+      initContainers:
+      - command:
+        - /root/ready.py
+        args:
+        - --container-name
+        - oof-has-music
+        env:
+        - name: NAMESPACE
+          valueFrom:
+            fieldRef:
+              apiVersion: v1
+              fieldPath: metadata.namespace
+        image: "{{ .Values.global.readinessRepository }}/{{ .Values.global.readinessImage }}"
+        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+        name: {{ include "common.name" . }}-readiness
+      containers:
+        - name: {{ include "common.name" . }}
+          image: "{{ include "common.repository" . }}/{{ .Values.global.image.optf_has }}"
+          imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+          command:
+          - python
+          args:
+          - /usr/local/bin/conductor-controller
+          - --config-file=/usr/local/bin/conductor.conf
+          # disable liveness probe when breakpoints set in debugger
+          # so K8s doesn't restart unresponsive container
+          {{- if .Values.liveness.enabled }}
+          livenessProbe:
+            exec:
+              command:
+              - cat
+              - /usr/local/bin/healthy.sh
+            initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.liveness.periodSeconds }}
+          {{ end -}}
+          readinessProbe:
+            exec:
+              command:
+              - cat
+              - /usr/local/bin/healthy.sh
+            initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.readiness.periodSeconds }}
+          env:
+          volumeMounts:
+          - mountPath: /etc/localtime
+            name: localtime
+            readOnly: true
+          - mountPath: /usr/local/bin/conductor.conf
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: conductor.conf
+          - mountPath: /usr/local/bin/log.conf
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: log.conf
+          - mountPath: /usr/local/bin/healthy.sh
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: healthy.sh
+          resources:
+{{ toYaml .Values.resources | indent 12 }}
+        {{- if .Values.nodeSelector }}
+        nodeSelector:
+{{ toYaml .Values.nodeSelector | indent 10 }}
+        {{- end -}}
+        {{- if .Values.affinity }}
+        affinity:
+{{ toYaml .Values.affinity | indent 10 }}
+        {{- end }}
+      volumes:
+        - name: localtime
+          hostPath:
+            path: /etc/localtime
+        - name: {{ .Values.global.commonConfigPrefix }}-config
+          configMap:
+            name: {{ .Values.global.commonConfigPrefix }}-configmap
+            items:
+            - key: conductor.conf
+              path: conductor.conf
+            - key: log.conf
+              path: log.conf
+            - key: healthy.sh
+              path: healthy.sh
+      imagePullSecrets:
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-controller/values.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-controller/values.yaml
new file mode 100755
index 0000000..57c56d5
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-controller/values.yaml
@@ -0,0 +1,30 @@
+# Copyright © 2017 Amdocs, AT&T, Bell Canada, VMware
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+ingress:
+  enabled: false
+replicaCount: 1
+nodeSelector: {}
+affinity: {}
+# probe configuration parameters
+liveness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+  # necessary to disable liveness probe when setting breakpoints
+  # in debugger so K8s doesn't restart unresponsive container
+  enabled: true
+readiness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+resources: {}
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-data/Chart.yaml
old mode 100644
new mode 100755
similarity index 87%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-data/Chart.yaml
index dd999e5..37d9f0d
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-data/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
+description: ONAP Homing and Allocation Service - Data Component
+name: oof-has-data
 version: 2.0.0
-
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-data/templates/deployment.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-data/templates/deployment.yaml
new file mode 100755
index 0000000..4effba8
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-data/templates/deployment.yaml
@@ -0,0 +1,129 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: {{ include "common.fullname" . }}
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+spec:
+  replicas: {{ .Values.replicaCount }}
+  template:
+    metadata:
+      labels:
+        app: {{ include "common.name" . }}
+        release: {{ .Release.Name }}
+    spec:
+      initContainers:
+      - command:
+        - /root/ready.py
+        args:
+        - --container-name
+        - oof-has-music
+        env:
+        - name: NAMESPACE
+          valueFrom:
+            fieldRef:
+              apiVersion: v1
+              fieldPath: metadata.namespace
+        image: "{{ .Values.global.readinessRepository }}/{{ .Values.global.readinessImage }}"
+        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+        name: {{ include "common.name" . }}-readiness
+      containers:
+        - name: {{ include "common.name" . }}
+          image: "{{ include "common.repository" . }}/{{ .Values.global.image.optf_has }}"
+          imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+          command:
+          - python
+          args:
+          - /usr/local/bin/conductor-data
+          - --config-file=/usr/local/bin/conductor.conf
+          # disable liveness probe when breakpoints set in debugger
+          # so K8s doesn't restart unresponsive container
+          {{- if .Values.liveness.enabled }}
+          livenessProbe:
+            exec:
+              command:
+              - cat
+              - /usr/local/bin/healthy.sh
+            initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.liveness.periodSeconds }}
+          {{ end -}}
+          readinessProbe:
+            exec:
+              command:
+              - cat
+              - /usr/local/bin/healthy.sh
+            initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.readiness.periodSeconds }}
+          env:
+          volumeMounts:
+          - mountPath: /etc/localtime
+            name: localtime
+            readOnly: true
+          - mountPath: /usr/local/bin/conductor.conf
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: conductor.conf
+          - mountPath: /usr/local/bin/log.conf
+            name: {{ .Values.global.commonConfigPrefix }}-config 
+            subPath: log.conf
+          - mountPath: /usr/local/bin/healthy.sh
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: healthy.sh 
+          - mountPath: /usr/local/bin/aai_cert.cer
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: aai_cert.cer
+          - mountPath: /usr/local/bin/aai_key.key
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: aai_key.key
+          - mountPath: /usr/local/bin/bundle.pem
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: bundle.pem
+          resources:
+{{ toYaml .Values.resources | indent 12 }}
+        {{- if .Values.nodeSelector }}
+        nodeSelector:
+{{ toYaml .Values.nodeSelector | indent 10 }}
+        {{- end -}}
+        {{- if .Values.affinity }}
+        affinity:
+{{ toYaml .Values.affinity | indent 10 }}
+        {{- end }}
+      volumes:
+        - name: localtime
+          hostPath:
+            path: /etc/localtime
+        - name: {{ .Values.global.commonConfigPrefix }}-config
+          configMap:
+            name: {{ .Values.global.commonConfigPrefix }}-configmap
+            items:
+            - key: conductor.conf
+              path: conductor.conf
+            - key: log.conf
+              path: log.conf
+            - key: healthy.sh
+              path: healthy.sh 
+            - key: aai_cert.cer
+              path: aai_cert.cer
+            - key: aai_key.key
+              path: aai_key.key
+            - key: bundle.pem
+              path: bundle.pem
+      imagePullSecrets:
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-data/values.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-data/values.yaml
new file mode 100755
index 0000000..57c56d5
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-data/values.yaml
@@ -0,0 +1,30 @@
+# Copyright © 2017 Amdocs, AT&T, Bell Canada, VMware
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+ingress:
+  enabled: false
+replicaCount: 1
+nodeSelector: {}
+affinity: {}
+# probe configuration parameters
+liveness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+  # necessary to disable liveness probe when setting breakpoints
+  # in debugger so K8s doesn't restart unresponsive container
+  enabled: true
+readiness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+resources: {}
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-music/Chart.yaml
similarity index 88%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-music/Chart.yaml
index dd999e5..a6653e4 100644
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-music/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
-version: 2.0.0
-
+description: ONAP OOF-MUSIC Container
+name: oof-has-music
+version: 2.5.3
diff --git a/kubernetes/message-router/charts/kafka/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-music/requirements.yaml
similarity index 87%
copy from kubernetes/message-router/charts/kafka/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-music/requirements.yaml
index b26f91a..1e8f788 100644
--- a/kubernetes/message-router/charts/kafka/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-music/requirements.yaml
@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-apiVersion: v1
-description: ONAP Global Kafka Service
-name: kafka
-version: 2.0.0
-
+dependencies:
+  - name: common
+    version: ~2.0.0
+    repository: '@local'
\ No newline at end of file
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-music/resources/config/music.properties
similarity index 60%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-music/resources/config/music.properties
index dd999e5..fe338a7 100644
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-music/resources/config/music.properties
@@ -12,8 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
-version: 2.0.0
-
+my.public.ip=localhost
+all.public.ips=localhost
+my.id=0
+all.ids=0
+#######################################
+# Optional current values are defaults
+#######################################
+zookeeper.host=oof-has-zk
+cassandra.host=oof-has-cassandra
+cassandra.user=root
+cassandra.password=Aa123456
+# AAF Endpoint if using AAF
+aaf.endpoint.url=https://aaf.api.simpledemo.onap.org
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-music/resources/config/startup.sh b/kubernetes/oof/charts/oof-has/charts/oof-has-music/resources/config/startup.sh
new file mode 100755
index 0000000..1648f9a
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-music/resources/config/startup.sh
@@ -0,0 +1,35 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+OUT=$(curl -o /dev/null -s -w "%{http_code}\n"  \
+  http://localhost:8080/MUSIC/rest/v2/admin/onboardAppWithMusic \
+  -H 'Cache-Control: no-cache' \
+  -H 'Content-Type: application/json' \
+  -H 'Postman-Token: 705d4a9d-aaf2-40b4-914a-e0ce1a79534c' \
+  -d '{
+   "appname": "conductor",
+   "userId" : "conductor",
+   "isAAF"  : false,
+   "password" : "c0nduct0r"
+}
+')
+
+if [ ${OUT} = "200" ]; then
+    echo "Success"
+    echo 1 > /tmp/onboarded
+    exit 0;
+else
+    echo "Failure"
+    exit 1;
+fi
diff --git a/kubernetes/message-router/charts/kafka/templates/NOTES.txt b/kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/NOTES.txt
similarity index 61%
copy from kubernetes/message-router/charts/kafka/templates/NOTES.txt
copy to kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/NOTES.txt
index c60c745..70f97db 100644
--- a/kubernetes/message-router/charts/kafka/templates/NOTES.txt
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/NOTES.txt
@@ -1,16 +1,30 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 1. Get the application URL by running these commands:
 {{- if .Values.ingress.enabled }}
 {{- range .Values.ingress.hosts }}
   http://{{ . }}
 {{- end }}
 {{- else if contains "NodePort" .Values.service.type }}
-  export NODE_PORT=$(kubectl get --namespace {{ include "common.namespace" . }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ include "common.name" . }})
+  export NODE_PORT=$(kubectl get --namespace {{ include "common.namespace" . }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ include "common.fullname" . }})
   export NODE_IP=$(kubectl get nodes --namespace {{ include "common.namespace" . }} -o jsonpath="{.items[0].status.addresses[0].address}")
   echo http://$NODE_IP:$NODE_PORT
 {{- else if contains "LoadBalancer" .Values.service.type }}
      NOTE: It may take a few minutes for the LoadBalancer IP to be available.
-           You can watch the status of by running 'kubectl get svc -w {{ include "common.name" . }}'
-  export SERVICE_IP=$(kubectl get svc --namespace {{ include "common.namespace" . }} {{ include "common.name" . }} -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
+           You can watch the status of by running 'kubectl get svc -w {{ include "common.fullname" . }}'
+  export SERVICE_IP=$(kubectl get svc --namespace {{ include "common.namespace" . }} {{ include "common.fullname" . }} -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
   echo http://$SERVICE_IP:{{ .Values.service.externalPort }}
 {{- else if contains "ClusterIP" .Values.service.type }}
   export POD_NAME=$(kubectl get pods --namespace {{ include "common.namespace" . }} -l "app={{ include "common.name" . }},release={{ .Release.Name }}" -o jsonpath="{.items[0].metadata.name}")
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/configmap.yaml
similarity index 74%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/configmap.yaml
index dd999e5..4ccc7cc 100644
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/configmap.yaml
@@ -13,7 +13,9 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
-version: 2.0.0
-
+kind: ConfigMap
+metadata:
+  name: {{ include "common.fullname" . }}-configmap
+  namespace: {{ include "common.namespace" . }}
+data:
+{{ tpl (.Files.Glob "resources/config/*").AsConfig . | indent 2 }}
\ No newline at end of file
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/deployment.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/deployment.yaml
new file mode 100644
index 0000000..17114d6
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/deployment.yaml
@@ -0,0 +1,86 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: {{ include "common.fullname" . }}
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+spec:
+  replicas: {{ .Values.replicaCount }}
+  template:
+    metadata:
+      labels:
+        app: {{ include "common.name" . }}
+        release: {{ .Release.Name }}
+    spec:
+      initContainers:
+# War Container
+       - name: "{{ include "common.name" . }}-war"
+         image: "{{ include "common.repository" . }}/{{ .Values.warImage }}"  #"
+         command: ["cp","/app/MUSIC.war","/webapps"]
+         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+         ports:
+         volumeMounts:
+         - mountPath: /webapps
+           name: shared-data
+      containers:
+      # Tomcat Container
+        - name: {{ include "common.name" . }}
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"   #"
+          imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+          ports:
+          - containerPort: {{ .Values.service.internalPort }}
+          # disable liveness probe when breakpoints set in debugger
+          # so K8s doesn't restart unresponsive container
+          {{- if eq .Values.liveness.enabled true }}
+          livenessProbe:
+            tcpSocket:
+              port: {{ .Values.service.internalPort }}
+            initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.liveness.periodSeconds }}
+          {{ end -}}
+          readinessProbe:
+            tcpSocket:
+              port: {{ .Values.service.internalPort }}
+            initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.readiness.periodSeconds }}
+          volumeMounts:
+          - mountPath: /etc/localtime
+            name: localtime
+            readOnly: true
+          - mountPath: /usr/local/tomcat/webapps
+            name: shared-data
+          - name: properties-music
+            mountPath: /opt/app/music/etc/music.properties
+            subPath: music.properties
+          - name: properties-music
+            mountPath: /opt/app/music/startup.sh
+            subPath: startup.sh
+      volumes:
+        - name: shared-data
+          emptyDir: {}
+        - name: localtime
+          hostPath:
+            path: /etc/localtime
+        - name: properties-music
+          configMap:
+            name: {{ include "common.fullname" . }}-configmap
+      imagePullSecrets:
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/message-router/charts/kafka/templates/service.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/service.yaml
similarity index 71%
copy from kubernetes/message-router/charts/kafka/templates/service.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/service.yaml
index c57d190..58d1ab6 100644
--- a/kubernetes/message-router/charts/kafka/templates/service.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-music/templates/service.yaml
@@ -15,18 +15,26 @@
 apiVersion: v1
 kind: Service
 metadata:
-  name: {{ .Values.service.name }}
+  name: {{ include "common.servicename" . }}
   namespace: {{ include "common.namespace" . }}
   labels:
     app: {{ include "common.name" . }}
     chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
     release: {{ .Release.Name }}
     heritage: {{ .Release.Service }}
+  annotations:
 spec:
+  type: {{ .Values.service.type }}
   ports:
+    {{if eq .Values.service.type "NodePort" -}}
+    - port: {{ .Values.service.externalPort }}
+      nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort }}
+      name: {{ .Values.service.portName }}
+    {{- else -}}
     - port: {{ .Values.service.externalPort }}
       targetPort: {{ .Values.service.internalPort }}
-      name: {{ .Values.service.name }}
+      name: {{ .Values.service.portName }}
+    {{- end}}
   selector:
     app: {{ include "common.name" . }}
     release: {{ .Release.Name }}
diff --git a/kubernetes/message-router/values.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-music/values.yaml
similarity index 63%
copy from kubernetes/message-router/values.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-music/values.yaml
index 181368d..c804cae 100644
--- a/kubernetes/message-router/values.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-music/values.yaml
@@ -17,9 +17,10 @@
 #################################################################
 global:
   nodePortPrefix: 302
+  repository: nexus3.onap.org:10001
   repositorySecret: eyJuZXh1czMub25hcC5vcmc6MTAwMDEiOnsidXNlcm5hbWUiOiJkb2NrZXIiLCJwYXNzd29yZCI6ImRvY2tlciIsImVtYWlsIjoiQCIsImF1dGgiOiJaRzlqYTJWeU9tUnZZMnRsY2c9PSJ9fQ==
   readinessRepository: oomk8s
-  readinessImage: readiness-check:2.0.0
+  readinessImage: readiness-check:1.0.0
   loggingRepository: docker.elastic.co
   loggingImage: beats/filebeat:5.5.0
 
@@ -28,23 +29,17 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/dmaap/dmaap-mr:1.1.4
+image: library/tomcat:8.5
 pullPolicy: Always
-
-nameOverride: dmaap
-
-kafka:
-  nameOverride: global-kafka
-zookeeper:
-  nameOverride: zookeeper
+warImage: onap/music/music:2.5.3
 
 # flag to enable debugging - application support required
 debugEnabled: false
 
 # application configuration
 config:
-  zookeeperPort: 2181
-  kafkaPort: 9092
+  usernameCassandra: cassandra1
+  passwordCassandra: cassandra1
 
 # default number of instances
 replicaCount: 1
@@ -67,31 +62,12 @@
 
 service:
   type: NodePort
-  name: message-router
-  portName: message-router
-  externalPort: 3904
-  nodePort: 27
-  externalPort2: 3905
-  nodePort2: 26
-
+  name: oof-has-music
+  externalPort: 8080
+  internalPort: 8080
+  nodePort: 76
+  portName: oof-has-music
 ingress:
   enabled: false
 
 resources: {}
-  # We usually recommend not to specify default resources and to leave this as a conscious
-  # choice for the user. This also increases chances charts run on environments with little
-  # resources, such as Minikube. If you do want to specify resources, uncomment the following
-  # lines, adjust them as necessary, and remove the curly braces after 'resources:'.
-  #
-  # Example:
-  # Configure resource requests and limits
-  # ref: http://kubernetes.io/docs/user-guide/compute-resources/
-  # Minimum memory for development is 2 CPU cores and 4GB memory
-  # Minimum memory for production is 4 CPU cores and 8GB memory
-#resources:
-#  limits:
-#    cpu: 2
-#    memory: 4Gi
-#  requests:
-#    cpu: 2
-#    memory: 4Gi
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-reservation/Chart.yaml
old mode 100644
new mode 100755
similarity index 86%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-reservation/Chart.yaml
index dd999e5..e74c556
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-reservation/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
+description: ONAP Homing and Allocation Sevice - Reservation Component
+name: oof-has-reservation
 version: 2.0.0
-
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-reservation/templates/deployment.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-reservation/templates/deployment.yaml
new file mode 100755
index 0000000..8b61021
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-reservation/templates/deployment.yaml
@@ -0,0 +1,114 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: {{ include "common.fullname" . }}
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+spec:
+  replicas: {{ .Values.replicaCount }}
+  template:
+    metadata:
+      labels:
+        app: {{ include "common.name" . }}
+        release: {{ .Release.Name }}
+    spec:
+      initContainers:
+      - command:
+        - /root/ready.py
+        args:
+        - --container-name
+        - oof-has-music
+        env:
+        - name: NAMESPACE
+          valueFrom:
+            fieldRef:
+              apiVersion: v1
+              fieldPath: metadata.namespace
+        image: "{{ .Values.global.readinessRepository }}/{{ .Values.global.readinessImage }}"
+        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+        name: {{ include "common.name" . }}-readiness
+      containers:
+        - name: {{ include "common.name" . }}
+          image: "{{ include "common.repository" . }}/{{ .Values.global.image.optf_has }}"
+          imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+          command:
+          - python
+          args:
+          - /usr/local/bin/conductor-reservation
+          - --config-file=/usr/local/bin/conductor.conf
+          # disable liveness probe when breakpoints set in debugger
+          # so K8s doesn't restart unresponsive container
+          {{- if .Values.liveness.enabled }}
+          livenessProbe:
+            exec:
+              command:
+              - cat
+              - /usr/local/bin/healthy.sh
+            initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.liveness.periodSeconds }}
+          readinessProbe:
+            exec:
+              command:
+              - cat
+              - /usr/local/bin/healthy.sh
+            initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.readiness.periodSeconds }}
+          {{ end -}}
+          env:
+          volumeMounts:
+          - mountPath: /etc/localtime
+            name: localtime
+            readOnly: true
+          - mountPath: /usr/local/bin/conductor.conf
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: conductor.conf
+          - mountPath: /usr/local/bin/log.conf
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: log.conf
+          - mountPath: /usr/local/bin/healthy.sh
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: healthy.sh
+          resources:
+{{ toYaml .Values.resources | indent 12 }}
+        {{- if .Values.nodeSelector }}
+        nodeSelector:
+{{ toYaml .Values.nodeSelector | indent 10 }}
+        {{- end -}}
+        {{- if .Values.affinity }}
+        affinity:
+{{ toYaml .Values.affinity | indent 10 }}
+        {{- end }}
+      volumes:
+        - name: localtime
+          hostPath:
+            path: /etc/localtime
+        - name: {{ .Values.global.commonConfigPrefix }}-config
+          configMap:
+            name: {{ .Values.global.commonConfigPrefix }}-configmap
+            items:
+            - key: conductor.conf
+              path: conductor.conf
+            - key: log.conf
+              path: log.conf
+            - key: healthy.sh
+              path: healthy.sh
+      imagePullSecrets:
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-reservation/values.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-reservation/values.yaml
new file mode 100755
index 0000000..57c56d5
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-reservation/values.yaml
@@ -0,0 +1,30 @@
+# Copyright © 2017 Amdocs, AT&T, Bell Canada, VMware
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+ingress:
+  enabled: false
+replicaCount: 1
+nodeSelector: {}
+affinity: {}
+# probe configuration parameters
+liveness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+  # necessary to disable liveness probe when setting breakpoints
+  # in debugger so K8s doesn't restart unresponsive container
+  enabled: true
+readiness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+resources: {}
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-solver/Chart.yaml
old mode 100644
new mode 100755
similarity index 87%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-solver/Chart.yaml
index dd999e5..ebad46b
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-solver/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
+description: ONAP Homing and Allocation Service - Solver Component
+name: oof-has-solver
 version: 2.0.0
-
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-solver/templates/deployment.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-solver/templates/deployment.yaml
new file mode 100755
index 0000000..9f9b4db
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-solver/templates/deployment.yaml
@@ -0,0 +1,114 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: {{ include "common.fullname" . }}
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+spec:
+  replicas: {{ .Values.replicaCount }}
+  template:
+    metadata:
+      labels:
+        app: {{ include "common.name" . }}
+        release: {{ .Release.Name }}
+    spec:
+      initContainers:
+      - command:
+        - /root/ready.py
+        args:
+        - --container-name
+        - oof-has-music
+        env:
+        - name: NAMESPACE
+          valueFrom:
+            fieldRef:
+              apiVersion: v1
+              fieldPath: metadata.namespace
+        image: "{{ .Values.global.readinessRepository }}/{{ .Values.global.readinessImage }}"
+        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+        name: {{ include "common.name" . }}-readiness
+      containers:
+        - name: {{ include "common.name" . }}
+          image: "{{ include "common.repository" . }}/{{ .Values.global.image.optf_has }}"
+          imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+          command:
+          - python
+          args:
+          - /usr/local/bin/conductor-solver
+          - --config-file=/usr/local/bin/conductor.conf
+          # disable liveness probe when breakpoints set in debugger
+          # so K8s doesn't restart unresponsive container
+          {{- if .Values.liveness.enabled }}
+          livenessProbe:
+            exec:
+              command:
+              - cat
+              - /usr/local/bin/healthy.sh
+            initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.liveness.periodSeconds }}
+          {{ end -}}
+          readinessProbe:
+            exec:
+              command:
+              - cat
+              - /usr/local/bin/healthy.sh
+            initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.readiness.periodSeconds }}
+          env:
+          volumeMounts:
+          - mountPath: /etc/localtime
+            name: localtime
+            readOnly: true
+          - mountPath: /usr/local/bin/conductor.conf
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: conductor.conf
+          - mountPath: /usr/local/bin/log.conf
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: log.conf
+          - mountPath: /usr/local/bin/healthy.sh
+            name: {{ .Values.global.commonConfigPrefix }}-config
+            subPath: healthy.sh
+          resources:
+{{ toYaml .Values.resources | indent 12 }}
+        {{- if .Values.nodeSelector }}
+        nodeSelector:
+{{ toYaml .Values.nodeSelector | indent 10 }}
+        {{- end -}}
+        {{- if .Values.affinity }}
+        affinity:
+{{ toYaml .Values.affinity | indent 10 }}
+        {{- end }}
+      volumes:
+        - name: localtime
+          hostPath:
+            path: /etc/localtime
+        - name: {{ .Values.global.commonConfigPrefix }}-config
+          configMap:
+            name: {{ .Values.global.commonConfigPrefix }}-configmap
+            items:
+            - key: conductor.conf
+              path: conductor.conf
+            - key: log.conf
+              path: log.conf
+            - key: healthy.sh
+              path: healthy.sh
+      imagePullSecrets:
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-solver/values.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-solver/values.yaml
new file mode 100755
index 0000000..57c56d5
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-solver/values.yaml
@@ -0,0 +1,30 @@
+# Copyright © 2017 Amdocs, AT&T, Bell Canada, VMware
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+ingress:
+  enabled: false
+replicaCount: 1
+nodeSelector: {}
+affinity: {}
+# probe configuration parameters
+liveness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+  # necessary to disable liveness probe when setting breakpoints
+  # in debugger so K8s doesn't restart unresponsive container
+  enabled: true
+readiness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+resources: {}
diff --git a/kubernetes/message-router/charts/kafka/Chart.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/Chart.yaml
similarity index 91%
copy from kubernetes/message-router/charts/kafka/Chart.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/Chart.yaml
index b26f91a..95033bb 100644
--- a/kubernetes/message-router/charts/kafka/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/Chart.yaml
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Global Kafka Service
-name: kafka
+description: ONAP OOF Zookeeper
+name: oof-has-zookeeper
 version: 2.0.0
-
diff --git a/kubernetes/message-router/charts/kafka/templates/NOTES.txt b/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/templates/NOTES.txt
similarity index 70%
copy from kubernetes/message-router/charts/kafka/templates/NOTES.txt
copy to kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/templates/NOTES.txt
index c60c745..8f907c0 100644
--- a/kubernetes/message-router/charts/kafka/templates/NOTES.txt
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/templates/NOTES.txt
@@ -1,3 +1,17 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 1. Get the application URL by running these commands:
 {{- if .Values.ingress.enabled }}
 {{- range .Values.ingress.hosts }}
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/templates/deployment.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/templates/deployment.yaml
new file mode 100644
index 0000000..c161f73
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/templates/deployment.yaml
@@ -0,0 +1,70 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: {{ include "common.fullname" . }}
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+spec:
+  replicas: {{ .Values.replicaCount }}
+  template:
+    metadata:
+      labels:
+        app: {{ include "common.name" . }}
+        release: {{ .Release.Name }}
+    spec:
+      containers:
+        - name: {{ include "common.name" . }}
+          image: {{ include "common.repository" . }}/{{ .Values.image }}
+          imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+          ports:
+          - containerPort: {{ .Values.service.internalPort }}
+          {{- if .Values.liveness.enabled }}
+          livenessProbe:
+            tcpSocket:
+              port: {{ .Values.service.internalPort }}
+            initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.liveness.periodSeconds }}
+          {{end -}}
+          readinessProbe:
+            tcpSocket:
+              port: {{ .Values.service.internalPort }}
+            initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
+            periodSeconds: {{ .Values.readiness.periodSeconds }}
+          volumeMounts:
+          - mountPath: /etc/localtime
+            name: localtime
+            readOnly: true
+          resources:
+{{ toYaml .Values.resources | indent 12 }}
+        {{- if .Values.nodeSelector }}
+        nodeSelector:
+{{ toYaml .Values.nodeSelector | indent 10 }}
+        {{- end -}}
+        {{- if .Values.affinity }}
+        affinity:
+{{ toYaml .Values.affinity | indent 10 }}
+        {{- end }}
+      volumes:
+        - name: localtime
+          hostPath:
+            path: /etc/localtime
+      imagePullSecrets:
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/message-router/charts/kafka/templates/service.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/templates/service.yaml
similarity index 74%
copy from kubernetes/message-router/charts/kafka/templates/service.yaml
copy to kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/templates/service.yaml
index c57d190..4e4c1c8 100644
--- a/kubernetes/message-router/charts/kafka/templates/service.yaml
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/templates/service.yaml
@@ -15,7 +15,7 @@
 apiVersion: v1
 kind: Service
 metadata:
-  name: {{ .Values.service.name }}
+  name: {{ include "common.servicename" . }}
   namespace: {{ include "common.namespace" . }}
   labels:
     app: {{ include "common.name" . }}
@@ -23,10 +23,16 @@
     release: {{ .Release.Name }}
     heritage: {{ .Release.Service }}
 spec:
+  type: {{ .Values.service.type }}
   ports:
+    {{if eq .Values.service.type "NodePort" -}}
+    - port: {{ .Values.service.internalPort }}
+      nodePort: {{ .Values.global.nodePortPrefix | default "302" }}{{ .Values.service.externalPort }}
+    {{- else -}}
     - port: {{ .Values.service.externalPort }}
       targetPort: {{ .Values.service.internalPort }}
-      name: {{ .Values.service.name }}
+    {{- end}}
+      name: {{ .Values.service.portName }}
   selector:
     app: {{ include "common.name" . }}
-    release: {{ .Release.Name }}
+    release: {{ .Release.Name }}
\ No newline at end of file
diff --git a/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/values.yaml b/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/values.yaml
new file mode 100644
index 0000000..7a069c6
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/charts/oof-has-zookeeper/values.yaml
@@ -0,0 +1,51 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Default values for mariadb.
+# This is a YAML-formatted file.
+# Declare variables to be passed into your templates.
+global: # global defaults
+  nodePortPrefix: 302
+  repositorySecret: eyJuZXh1czMub25hcC5vcmc6MTAwMDEiOnsidXNlcm5hbWUiOiJkb2NrZXIiLCJwYXNzd29yZCI6ImRvY2tlciIsImVtYWlsIjoiQCIsImF1dGgiOiJaRzlqYTJWeU9tUnZZMnRsY2c9PSJ9fQ==
+  persistence: {}
+
+
+# application image
+repository: nexus3.onap.org:10001
+image: zookeeper:3.4
+pullPolicy: Always
+
+# default number of instances
+replicaCount: 1
+nodeSelector: {}
+affinity: {}
+# probe configuration parameters
+liveness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+  # necessary to disable liveness probe when setting breakpoints
+  # in debugger so K8s doesn't restart unresponsive container
+  enabled: true
+readiness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+service:
+  type: ClusterIP
+  name: oof-has-zk
+  externalPort: 2181
+  internalPort: 2181
+  portName: oof-has-zookeeper
+ingress:
+  enabled: false
+resources: {}
diff --git a/kubernetes/message-router/charts/kafka/Chart.yaml b/kubernetes/oof/charts/oof-has/requirements.yaml
old mode 100644
new mode 100755
similarity index 87%
copy from kubernetes/message-router/charts/kafka/Chart.yaml
copy to kubernetes/oof/charts/oof-has/requirements.yaml
index b26f91a..ce82a2f
--- a/kubernetes/message-router/charts/kafka/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/requirements.yaml
@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-apiVersion: v1
-description: ONAP Global Kafka Service
-name: kafka
-version: 2.0.0
-
+dependencies:
+  - name: common
+    version: ~2.0.0
+    repository: '@local'
diff --git a/kubernetes/oof/charts/oof-has/resources/config/aai_cert.cer b/kubernetes/oof/charts/oof-has/resources/config/aai_cert.cer
new file mode 100755
index 0000000..4c6eb91
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/resources/config/aai_cert.cer
@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIEKjCCAxKgAwIBAgIBHjANBgkqhkiG9w0BAQsFADBHMQswCQYDVQQGEwJVUzEN
+MAsGA1UECgwET05BUDEOMAwGA1UECwwFT1NBQUYxGTAXBgNVBAMMEGludGVybWVk
+aWF0ZUNBXzEwHhcNMTgwNDI1MTIxMzAxWhcNMTkwNDIwMTIxMzAxWjBtMQswCQYD
+VQQGEwJVUzENMAsGA1UECgwET05BUDEZMBcGA1UECwwQb29mQG9vZi5vbmFwLm9y
+ZzEOMAwGA1UECwwFT1NBQUYxJDAiBgNVBAMMG29vZi5hcGkuc2ltcGxlZGVtby5v
+bmFwLm9yZzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANGpQUtgLXG3
+dVikd/QC2Q24wzeTOeZzbx3PnidNYZT5K0sJ/TdnZF6O/4+9gXQ6AQS2Q8wfQ009
+MQAA5vhUaq5yZ2K+XAtEFGln1TxTFpGu3WDOwQ800Vw18Dk8WidrkzDJv489Bn1f
+SSaPC0IaRB0K1d8BD63ZHgsuEY8lt31DX2wFWJcfN9mxNDzuLTZoLxtxKsedoZKH
+rsOOILwXOhwuunfx40i6RQN/pFX6C2i8dtOA5OwUm9Q1RrZ2Tv1Uf4IURriH6bfZ
+5n50yxTuL22TMYXsF/ohrdgwacuC0aV9ZSGhIZUJPyHVg7+QTBioHmoUJInVKuIx
+kkC4lENbLYUCAwEAAaOB+jCB9zAJBgNVHRMEAjAAMBEGCWCGSAGG+EIBAQQEAwIG
+wDAzBglghkgBhvhCAQ0EJhYkT3BlblNTTCBHZW5lcmF0ZWQgU2VydmVyIENlcnRp
+ZmljYXRlMB0GA1UdDgQWBBQwbU5oHU2iYHCoVz4hFCvBW59cdTBUBgNVHSMETTBL
+gBQd5lldG54KOKRipsGF8/PP1vGX6qEwpC4wLDEOMAwGA1UECwwFT1NBQUYxDTAL
+BgNVBAoMBE9OQVAxCzAJBgNVBAYTAlVTggEBMA4GA1UdDwEB/wQEAwIF4DAdBgNV
+HSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwDQYJKoZIhvcNAQELBQADggEBADEa
+0VuxoFIygeQTqlizpHNwfApPmlAVSKDTWuEu4rhJs8GT61EuWZQPygXEUHCYmGvJ
+GMwEGGIDGiQqxMqlqng46gksNJbi1ktXr6Du18qW7gziUd84ve8KcecjZru1Sk1e
+UJ/6WEQVE17CHKcnzQZsMDakgP+61VgKbk5NlkeF/Qh4L6/3jY7g+xoXqaId5RT9
+BetmH/cMsj33lxQTs0fcXTbAQd6BX5ug854OJ1mU4ngJnNBdmn9Ow1bB71ohf5Xv
+OEYX8+khjgjlmM0u1hBRL4qViv3y2Gzhpm1M8cETMDj4g0zIJytzIYMxO8XvDPCF
+YmVZHXJDLsCogSOmmh0=
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/kubernetes/oof/charts/oof-has/resources/config/aai_key.key b/kubernetes/oof/charts/oof-has/resources/config/aai_key.key
new file mode 100755
index 0000000..246ff6d
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/resources/config/aai_key.key
@@ -0,0 +1,30 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIIFDjBABgkqhkiG9w0BBQ0wMzAbBgkqhkiG9w0BBQwwDgQIvxjZPeQVkRACAggA
+MBQGCCqGSIb3DQMHBAhWqwQCjZFCrASCBMjWG5wsC1WFJISJ5odMHzYOWOKLpaDP
+7a/dxnBrV6gId/DTmzoqtiBCmQRqhnUuYok98DNUFGjR9JqztNNOf5eslzqCugsh
+zVwCvsJYKvxxJ4Q8tow3DKx28I6EmOvwudMsL9c30OxpEWdlWmyFimu5JDdDvWUH
+S0fWKebQETZ7lptiRX2IXhC3Ye6Wu/DowDYc5L4Z/Q8nwncMB3n2ntMX10pBrura
+15/R18AvG5cDwcasTXz5WKIB/K2onvJfW0so2M8jApu2DF4MpEIN9Z973uTNFXcL
+dgHKWtIl2WO38coedaXUILgsxLSSU27TG4F+7QMGjiKXUSWjN9+TD+8zWye/9OIW
+qfVtoh+n7lWtzC3Axo1OmPInCkFb+I7QaDsJgsUn+ZWap7FVJFrYiz20UTzYYgAK
+OukCgKiJTHOhTT1k0km34ROPmqOk6mH7IkioUSTmoP362RpIVTbKv2e5GKzhYfkk
+27W3RRG/qoZLUTU2AaAyoGZlzXDkBFw2g4vxnhcfHeXX6jyJyQWOOOeRJ5B6uc+Y
+4XmKKJvq5pFlxUDmVCZLRzjwpvYPTQwTQQ9t7kEZFI8B7TMkDqv62YlXyoWNDwPq
+yLvDwPDicx33AZor8N/eDgIOE+TXQ0vEyphf0c9OcgneeJmEtn7IskEahv32ruMQ
+uFAAuIUmQfXPNMXu3MYIUItvZDm3RUk3YJDj9c8YtvxDlzLytHu5QYJ3v7rvo+mG
+XKwmnZouaNRLw5Y7Mff07BuTPuttyNadacuJtUjvv8qVOIeuxQ7nku6yqKKLTeJr
+8E4/tYyZ15FIo3hWi16h3zyZ9LiHhhe7d2XYSVMuzuD4jkIdHbdgiKsCJn9mI5PF
+VpDF34w1Fjwv7Gu32MRMpJijAW10ENaP1O2izr9l8jwo+CLgi5qa6a2YTYAZooqt
+UjTLfEIQKbwFbq5L9Eb1uRw1lRR9SxcxdNQdY+mtx0x2BSmXVUEcyi6OG/8Lzf/1
+9VoE5UPfhSE7ogfbL8eraFlQmKL8f3h3Jx/XDvvKC8YXxgooEhV0BsofXmLdF0BK
+bhXR1/JptLz8CJjtlBWQkmqj+ONOHFA9/4YHMNn5T1PBLNzQCZSjQXrDKxowLDsI
+ozUyZ080c2LrJCf6zj6+fB3LDvHYfJ6LnYASCHJlNS0NVmRPiYB/dmoqF/iyAEjp
+cKUUrbhs6U95aPMo0pPSCuhLKiibCo3Vz/9dvGb7pr6aj/ehOjrtKtGlYukBqNkS
+RQK2kkL8IO+iPWs3aCnEhfeS+wNBMAtI/TEw6As2zseyb3/SylHjek4s1gs9MPdw
+c3o2ArwMzmP0sfFIjYz+AyQm+5i/LSnkNjG0OU9ekGXy7Z4HAcko2Dv8/SmOVapP
+cf8c55RUDlYJh9Ltn0W5fuNA6dykV7f9s8BIrZcnzTN+lifNhNlEYYcmyZwlCcX4
+NBLoH+ENW+Q7+nuhGcf52j/XgTaPZ0Eec8ZJdK7FzVDN4DWKM4KHD7DgpkOR7TZl
+IKGNtdvb3SaGG83YlJhRkkr0C2KvB0Mz2dkAhOKX3NkBr5fY62IvuMdqD7VDjGAw
+h/GBn0k5+gpVP0Uh6yWEla3CjM9GnUuMVcwIUAYSeW2rFu4iapK0gBwguR91cM1N
+MA8=
+-----END ENCRYPTED PRIVATE KEY-----
diff --git a/kubernetes/oof/charts/oof-has/resources/config/bundle.pem b/kubernetes/oof/charts/oof-has/resources/config/bundle.pem
new file mode 100755
index 0000000..60121e7
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/resources/config/bundle.pem
@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIEVDCCAjygAwIBAgIBATANBgkqhkiG9w0BAQsFADAsMQ4wDAYDVQQLDAVPU0FB
+RjENMAsGA1UECgwET05BUDELMAkGA1UEBhMCVVMwHhcNMTgwNDA1MTQxNTQwWhcN
+MTgwNjA0MTQxNTQwWjBHMQswCQYDVQQGEwJVUzENMAsGA1UECgwET05BUDEOMAwG
+A1UECwwFT1NBQUYxGTAXBgNVBAMMEGludGVybWVkaWF0ZUNBXzEwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCY3YPA/YQdz4kaZQzdRzWNjmn33WYAWZ8+
+EIz3PhkEzk7M1q9N7Icx2LvozMj4VH0yGz/HYlliHhw26ZRsjYMSR8zATsXl4oW9
+w9BrjuyvM3w8Ptxe8WbUFF9LJDGyXPeVvcXVo0iyh3QYPWC/AWmomN19MvBFN5vH
+AvEG/7qtonViNfISW9Gr9LpXB0foCmUDBu/lV+SwRGajoCPqdZhZ6/L6/yqDvha2
+wsML/UZXlGhXAedt/xOKmT/dSXx/I0vWBVp6Tq4zu87yCvd+I6Tpa5HjttA2I5EV
+zdHX+JYBPBBcVCyO9YQOYjJuoVDE4D5etY6dEipKG/KZF/rqAoqZAgMBAAGjZjBk
+MB0GA1UdDgQWBBQd5lldG54KOKRipsGF8/PP1vGX6jAfBgNVHSMEGDAWgBRTVTPy
+S+vQUbHBeJrBKDF77+rtSTASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQE
+AwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAmgeiitBDi/YEqFh2Cqp0VIEqw8hiuV87
+rADQWMK4hv5WXl3KJTjFAnWsYFUKrm6s1jNH16FyGExUQgwggob0Vt+MHiUs36jU
+kyret/uE5qrjz+/J+i2XG6s1oKcDRVD/jU4qBygZWFBMuwl7sz8IEvaYXGM43s96
+Du3UF9E+V3aMppqkGWz6MnrTmANnWAlDAMeifcoexjrpxiKbp8f49HX1UzwFoeEg
+RnVwNqgDWT66yGV6mbNl6FpE/U81RpCRY1ZJDeVTxbqIaG/UPV4hpQ+BEVBDF+cb
+rGsvsNYYpWx5srIQ7WtGKIlaDFbfWPwnHDHegzr8ypAS3KNWULE+QXCbHWtB+b0Y
+WhP/2F6Jjb+ByvJqQoE+nHEYBeUOZUUZC4IuQFNJ5Wy5P0CNXdheiWhdrBmG02Gy
+KMi0FJx6BEoWM2xcdl6bn5j9mhF4TX7zgepNWlgTra4Z8Oz8iqbQk33/s2OKM4ic
+6ZezUYhNp+MuUt4Se+ufNcGV65jnUKeROtWzNLwP+xwglEFlG8aNiAORthd7QJuT
+Ey2cX7H7f38ENQ5YCriUk1nVLO9F66l/rNRzYZgQzRI3IvDW8vyM2TLW2mcZNsaf
+qjFMcCDweV2FRb8eTbmWzzB2/xTVpGzVJqzwgE+U7UtJx5CZS3wPkvXuEgvcg1tY
+m1r4NGYFvLM=
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/kubernetes/oof/charts/oof-has/resources/config/conductor.conf b/kubernetes/oof/charts/oof-has/resources/config/conductor.conf
new file mode 100755
index 0000000..4d32dee
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/resources/config/conductor.conf
@@ -0,0 +1,357 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+[DEFAULT]
+
+#
+# From conductor
+#
+
+# Configuration file for WSGI definition of API. (string value)
+#api_paste_config = api_paste.ini
+
+# Music keyspace for content (string value)
+keyspace = conductor
+
+#
+# From oslo.log
+#
+
+# If set to true, the logging level will be set to DEBUG instead of the default
+# INFO level. (boolean value)
+# Note: This option can be changed without restarting.
+debug = true
+
+# DEPRECATED: If set to false, the logging level will be set to WARNING instead
+# of the default INFO level. (boolean value)
+# This option is deprecated for removal.
+# Its value may be silently ignored in the future.
+#verbose = true
+
+# The name of a logging configuration file. This file is appended to any
+# existing logging configuration files. For details about logging configuration
+# files, see the Python logging module documentation. Note that when logging
+# configuration files are used then all logging configuration is set in the
+# configuration file and other logging configuration options are ignored (for
+# example, logging_context_format_string). (string value)
+# Note: This option can be changed without restarting.
+# Deprecated group/name - [DEFAULT]/log_config
+# log_config_append = /usr/local/bin/log.conf
+
+# Defines the format string for %%(asctime)s in log records. Default:
+# %(default)s . This option is ignored if log_config_append is set. (string
+# value)
+#log_date_format = %Y-%m-%d %H:%M:%S
+
+# (Optional) Name of log file to send logging output to. If no default is set,
+# logging will go to stderr as defined by use_stderr. This option is ignored if
+# log_config_append is set. (string value)
+# Deprecated group/name - [DEFAULT]/logfile
+#log_file = <None>
+
+# (Optional) The base directory used for relative log_file  paths. This option
+# is ignored if log_config_append is set. (string value)
+# Deprecated group/name - [DEFAULT]/logdir
+#log_dir = <None>
+
+# Uses logging handler designed to watch file system. When log file is moved or
+# removed this handler will open a new log file with specified path
+# instantaneously. It makes sense only if log_file option is specified and
+# Linux platform is used. This option is ignored if log_config_append is set.
+# (boolean value)
+#watch_log_file = false
+
+# Use syslog for logging. Existing syslog format is DEPRECATED and will be
+# changed later to honor RFC5424. This option is ignored if log_config_append
+# is set. (boolean value)
+#use_syslog = false
+
+# Syslog facility to receive log lines. This option is ignored if
+# log_config_append is set. (string value)
+#syslog_log_facility = LOG_USER
+
+# Log output to standard error. This option is ignored if log_config_append is
+# set. (boolean value)
+#use_stderr = false
+
+# Format string to use for log messages with context. (string value)
+#logging_context_format_string = %(asctime)s.%(msecs)03d %(process)d %(levelname)s %(name)s [%(request_id)s %(user_identity)s] %(instance)s%(message)s
+
+# Format string to use for log messages when context is undefined. (string
+# value)
+#logging_default_format_string = %(asctime)s.%(msecs)03d %(process)d %(levelname)s %(name)s [-] %(instance)s%(message)s
+
+# Additional data to append to log message when logging level for the message
+# is DEBUG. (string value)
+#logging_debug_format_suffix = %(funcName)s %(pathname)s:%(lineno)d
+
+# Prefix each line of exception output with this format. (string value)
+#logging_exception_prefix = %(asctime)s.%(msecs)03d %(process)d ERROR %(name)s %(instance)s
+
+# Defines the format string for %(user_identity)s that is used in
+# logging_context_format_string. (string value)
+#logging_user_identity_format = %(user)s %(tenant)s %(domain)s %(user_domain)s %(project_domain)s
+
+# List of package logging levels in logger=LEVEL pairs. This option is ignored
+# if log_config_append is set. (list value)
+#default_log_levels = amqp=WARN,amqplib=WARN,boto=WARN,qpid=WARN,sqlalchemy=WARN,suds=INFO,oslo.messaging=INFO,iso8601=WARN,requests.packages.urllib3.connectionpool=WARN,urllib3.connectionpool=WARN,websocket=WARN,requests.packages.urllib3.util.retry=WARN,urllib3.util.retry=WARN,keystonemiddleware=WARN,routes.middleware=WARN,stevedore=WARN,taskflow=WARN,keystoneauth=WARN,oslo.cache=INFO,dogpile.core.dogpile=INFO
+
+# Enables or disables publication of error events. (boolean value)
+#publish_errors = false
+
+# The format for an instance that is passed with the log message. (string
+# value)
+#instance_format = "[instance: %(uuid)s] "
+
+# The format for an instance UUID that is passed with the log message. (string
+# value)
+#instance_uuid_format = "[instance: %(uuid)s] "
+
+# Interval, number of seconds, of log rate limiting. (integer value)
+#rate_limit_interval = 0
+
+# Maximum number of logged messages per rate_limit_interval. (integer value)
+#rate_limit_burst = 0
+
+# Log level name used by rate limiting: CRITICAL, ERROR, INFO, WARNING, DEBUG
+# or empty string. Logs with level greater or equal to rate_limit_except_level
+# are not filtered. An empty string means that all levels are filtered. (string
+# value)
+#rate_limit_except_level = CRITICAL
+
+# Enables or disables fatal status of deprecations. (boolean value)
+#fatal_deprecations = false
+
+
+[aai]
+
+#
+# From conductor
+#
+
+# Interval with which to refresh the local cache, in minutes. (integer value)
+cache_refresh_interval = 1
+complex_cache_refresh_interval = 60
+
+# Data Store table prefix. (string value)
+#table_prefix = aai
+
+# Base URL for A&AI, up to and not including the version, and without a
+# trailing slash. (string value)
+server_url = https://oof.api.simpledemo.onap.org:8443/aai
+
+# The version of A&AI in v# format. (string value)
+server_url_version = v11
+
+# SSL/TLS certificate file in pem format. This certificate must be registered
+# with the A&AI endpoint. (string value)
+certificate_file = /usr/local/bin/aai_cert.cer
+
+# Private Certificate Key file in pem format. (string value)
+certificate_key_file = /usr/local/bin/aai_key.key
+
+# Certificate Authority Bundle file in pem format. Must contain the appropriate
+# trust chain for the Certificate file. (string value)
+#certificate_authority_bundle_file = /opt/app/conductor/etc/certs/ca_bundle.pem
+certificate_authority_bundle_file =/usr/local/bin/bundle.pem
+
+[api]
+
+#
+# From conductor
+#
+
+# Toggle Pecan Debug Middleware. (boolean value)
+#pecan_debug = false
+
+# Default maximum number of items returned by API request. (integer value)
+# Minimum value: 1
+#default_api_return_limit = 100
+
+[conductor_api]
+
+# Basic Authentication Username (string value)
+username = admin1
+
+# Basic Authentication Password (string value)
+password = plan.15
+
+basic_auth_secure = False
+
+[controller]
+
+#
+# From conductor
+#
+
+# Timeout for planning requests. Default value is 10. (integer value)
+# Minimum value: 1
+timeout = 200
+
+# Maximum number of result sets to return. Default value is 1. (integer value)
+# Minimum value: 1
+#limit = 1
+
+# Number of workers for controller service. Default value is 1. (integer value)
+# Minimum value: 1
+#workers = 1
+
+# Time between checking for new plans. Default value is 1. (integer value)
+# Minimum value: 1
+#polling_interval = 1
+concurrent = true
+
+
+[inventory_provider]
+
+#
+# From conductor
+#
+
+# Extensions list to use (list value)
+#extensions = aai
+
+
+[messaging_server]
+
+#
+# From conductor
+#
+
+# Music keyspace for messages (string value)
+keyspace = conductor_rpc
+
+# Wait interval while checking for a message response. Default value is 1
+# second. (integer value)
+# Minimum value: 1
+#check_interval = 1
+
+# Overall message response timeout. Default value is 10 seconds. (integer
+# value)
+# Minimum value: 1
+timeout = 300
+
+# Number of workers for messaging service. Default value is 1. (integer value)
+# Minimum value: 1
+#workers = 1
+
+# Time between checking for new messages. Default value is 1. (integer value)
+# Minimum value: 1
+#polling_interval = 1
+
+# Log debug messages. Default value is False. (boolean value)
+#debug = false
+
+
+[music_api]
+
+#
+# From conductor
+#
+music_new_version = True
+# Base URL for Music REST API without a trailing slash. (string value)
+server_url = http://oof-has-music:8080/MUSIC/rest/v2
+version = v2
+music_version = "2.5.3"
+aafuser = conductor
+aafpass = c0nduct0r
+aafns = conductor
+
+# DEPRECATED: List of hostnames (round-robin access) (list value)
+# This option is deprecated for removal.
+# Its value may be silently ignored in the future.
+# Reason: Use server_url instead
+#hostnames = <None>
+
+# DEPRECATED: Port (integer value)
+# This option is deprecated for removal.
+# Its value may be silently ignored in the future.
+# Reason: Use server_url instead
+#port = <None>
+
+# DEPRECATED: Path (string value)
+# This option is deprecated for removal.
+# Its value may be silently ignored in the future.
+# Reason: Use server_url instead
+#path = <None>
+
+# Lock timeout (integer value)
+#lock_timeout = 10
+replication_factor = 1
+# Log debug messages. Default value is False. (boolean value)
+#debug = false
+
+# Use mock API (boolean value)
+#mock = false
+
+# Socket connection timeout (floating point value)
+connect_timeout = 3.05
+
+# Socket read timeout (floating point value)
+read_timeout = 12.05
+
+
+
+[sdnc]
+
+#
+# From conductor
+#
+
+# Interval with which to refresh the local cache, in minutes. (integer value)
+#cache_refresh_interval = 1440
+
+# Data Store table prefix. (string value)
+#table_prefix = sdnc
+
+# Base URL for SDN-C, up to and including the version. (string value)
+server_url = https://sdncodl-conexus-e2e.ecomp.cci.att.com:8543/restconf/
+
+# Basic Authentication Username (string value)
+username = admin
+
+# Basic Authentication Password (string value)
+password = sdnc.15
+
+
+[service_controller]
+
+#
+# From conductor
+#
+
+# Extensions list to use (list value)
+#extensions = sdnc
+
+
+[solver]
+
+#
+# From conductor
+#
+
+# Number of workers for solver service. Default value is 1. (integer value)
+# Minimum value: 1
+#workers = 1
+
+# Set to True when solver will run in active-active mode. When set to False,
+# solver will restart any orphaned solving requests at startup. (boolean value)
+#concurrent = false
+concurrent = true
+
+
+
+[reservation]
+concurrent = true
+
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/resources/config/healthy.sh
old mode 100644
new mode 100755
similarity index 62%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/resources/config/healthy.sh
index dd999e5..9b53975
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/resources/config/healthy.sh
@@ -12,8 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
-version: 2.0.0
+#!/bin/bash
 
+# Controller is a process that reads from Music Q
+# It uses no ports (TCP or HTTP). The PROB will check
+# if the controller process exists or not. In case
+# it exists, it will send 0, else send 1 so k8s can i
+# restart the container
+
+pid="$(pgrep -f '/usr/local/bin/conductor')"
+if [ -z "$pid" ]
+then
+   echo 1
+else
+   echo 0
+fi
diff --git a/kubernetes/oof/charts/oof-has/resources/config/log.conf b/kubernetes/oof/charts/oof-has/resources/config/log.conf
new file mode 100755
index 0000000..4dc2793
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/resources/config/log.conf
@@ -0,0 +1,78 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+[loggers]
+keys=root
+
+[handlers]
+keys=trfhand,consoleHandler,audithand,metrichand,errhand,debughand
+
+[logger_root]
+level=NOTSET
+handlers=trfhand,consoleHandler,audithand,metrichand,errhand,debughand
+
+[handler_consoleHandler]
+class=StreamHandler
+level=NOTSET
+formatter=generic
+args=(sys.stdout,)
+
+[handler_trfhand]
+class=handlers.TimedRotatingFileHandler
+level=NOTSET
+formatter=generic
+args=('application.log','midnight', 1, 10)
+
+[handler_audithand]
+class=handlers.TimedRotatingFileHandler
+level=INFO
+formatter=audit
+args=('audit.log', 'midnight', 1, 10)
+
+[handler_metrichand]
+class=handlers.TimedRotatingFileHandler
+level=INFO
+formatter=metric
+args=('metric.log','midnight', 1, 10)
+
+[handler_errhand]
+class=handlers.TimedRotatingFileHandler
+level=ERROR
+formatter=error
+args=('error.log','midnight', 1, 10)
+
+[handler_debughand]
+class=handlers.TimedRotatingFileHandler
+level=DEBUG
+formatter=generic
+args=('debug.log','midnight', 1, 10)
+
+[formatters]
+keys=generic,audit,metric,error
+
+[formatter_audit]
+format=%(asctime)s|%(asctime)s|00000000-0000-0000-0000-000000000000||%(thread)d||Conductor|N/A|COMPLETE|200|sucessful||%(levelname)s|||0|%(module)s|||||||||%(name)s : [-] %(message)s
+datefmt=
+
+[formatter_metric]
+format=%(asctime)s|%(asctime)s|00000000-0000-0000-0000-000000000000||%(thread)d||Conductor|N/A|N/A|N/A|COMPLETE|200|sucessful||%(levelname)s|||0|%(module)s||||||||||%(name)s : [-] %(message)s
+datefmt=
+
+[formatter_error]
+format=%(asctime)s|00000000-0000-0000-0000-000000000000|%(thread)d|Conductor|N/A|N/A|N/A|ERROR|500|N/A|%(name)s : [-] %(message)s
+datefmt=
+
+[formatter_generic]
+format=%(asctime)s||%(thread)d|%(levelname)s|%(module)s|%(name)s: [-] %(message)s
+datefmt=
diff --git a/kubernetes/oof/charts/oof-has/resources/config/log/filebeat.yml b/kubernetes/oof/charts/oof-has/resources/config/log/filebeat.yml
new file mode 100755
index 0000000..7c8ddec
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/resources/config/log/filebeat.yml
@@ -0,0 +1,31 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+filebeat.prospectors:
+#it is mandatory, in our case it's log
+- input_type: log
+  #This is the canolical path as mentioned in logback.xml, *.* means it will monitor all files in the directory.
+  paths:
+    - /var/log/onap/*/*/*/*.log
+    - /var/log/onap/*/*/*.log
+    - /var/log/onap/*/*.log
+  #Files older than this should be ignored.In our case it will be 48 hours i.e. 2 days. It is a helping flag for clean_inactive
+  ignore_older: 48h
+  # Remove the registry entry for a file that is more than the specified time. In our case it will be 96 hours, i.e. 4 days. It will help to keep registry records with in limit
+  clean_inactive: 96h
+
+
+# Name of the registry file. If a relative path is used, it is considered relative to the
+# data path. Else full qualified file name.
+#filebeat.registry_file: ${path.data}/registry
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/charts/oof-has/templates/configmap.yaml
old mode 100644
new mode 100755
similarity index 74%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/charts/oof-has/templates/configmap.yaml
index dd999e5..78e63d4
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/charts/oof-has/templates/configmap.yaml
@@ -13,7 +13,9 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
-version: 2.0.0
-
+kind: ConfigMap
+metadata:
+  name: {{ .Values.global.commonConfigPrefix }}-configmap
+  namespace: {{ include "common.namespace" . }}
+data:
+{{ tpl (.Files.Glob "resources/config/*").AsConfig . | indent 2 }}
\ No newline at end of file
diff --git a/kubernetes/oof/charts/oof-has/values.yaml b/kubernetes/oof/charts/oof-has/values.yaml
new file mode 100755
index 0000000..52428bd
--- /dev/null
+++ b/kubernetes/oof/charts/oof-has/values.yaml
@@ -0,0 +1,34 @@
+# Copyright © 2017 Amdocs, AT&T, Bell Canada, VMware
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#################################################################
+# Global configuration defaults.
+#################################################################
+global:
+  repositorySecret: eyJuZXh1czMub25hcC5vcmc6MTAwMDEiOnsidXNlcm5hbWUiOiJkb2NrZXIiLCJwYXNzd29yZCI6ImRvY2tlciIsImVtYWlsIjoiQCIsImF1dGgiOiJaRzlqYTJWeU9tUnZZMnRsY2c9PSJ9fQ==
+  readinessRepository: oomk8s
+  readinessImage: readiness-check:1.0.0
+  loggingRepository: docker.elastic.co
+  loggingImage: beats/filebeat:5.5.0
+  repository: nexus3.onap.org:10001
+  commonConfigPrefix: onap-oof-has
+  image:
+    readiness: oomk8s/readiness-check:1.1.0
+    optf_has: onap/optf-has:1.1.1
+    filebeat: docker.elastic.co/beats/filebeat:5.5.0
+
+nsPrefix: onap
+pullPolicy: Always
+nodePortPrefix: 302
+dataRootDir: /dockerdata-nfs
diff --git a/kubernetes/message-router/charts/kafka/Chart.yaml b/kubernetes/oof/requirements.yaml
old mode 100644
new mode 100755
similarity index 87%
copy from kubernetes/message-router/charts/kafka/Chart.yaml
copy to kubernetes/oof/requirements.yaml
index b26f91a..ce82a2f
--- a/kubernetes/message-router/charts/kafka/Chart.yaml
+++ b/kubernetes/oof/requirements.yaml
@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-apiVersion: v1
-description: ONAP Global Kafka Service
-name: kafka
-version: 2.0.0
-
+dependencies:
+  - name: common
+    version: ~2.0.0
+    repository: '@local'
diff --git a/kubernetes/oof/resources/config/osdf_config.yaml b/kubernetes/oof/resources/config/osdf_config.yaml
new file mode 100755
index 0000000..7fe63a5
--- /dev/null
+++ b/kubernetes/oof/resources/config/osdf_config.yaml
@@ -0,0 +1,53 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# Credentials for the OOF placement service – SO. Newly added.
+osdfPlacementSOUsername: {{ .Values.config.osdfPlacementSOUsername }}
+osdfPlacementSOPassword: {{ .Values.config.osdfPlacementSOPassword }}
+
+# Credentials for the OOF CM scheduling service – Generic. Newly added
+osdfCMSchedulerUsername: {{ .Values.config.osdfCMSchedulerUsername }}
+osdfCMSchedulerPassword: {{ .Values.config.osdfCMSchedulerPassword }}
+
+# msoUrl: ""   # The SO url for call back. This will be part of the request, so no need
+soUsername: {{ .Values.config.soUsername }}
+soPassword: {{ .Values.config.soPassword }}
+
+conductorUrl: "{{.Release.Name}}-has-api.{{include "common.namespace" .}}:TODO-PORT-FOR-HAS-API"
+conductorUsername: {{ .Values.config.conductorUsername }}
+conductorPassword: {{ .Values.config.conductorPassword }}
+conductorPingWaitTime: {{ .Values.config.conductorPingWaitTime }}
+conductorMaxRetries: {{ .Values.config.conductorMaxRetries }}
+
+# Policy Platform -- requires ClientAuth, Authorization, and Environment
+policyPlatformUrl: {{ .Values.config.policyPlatformUrl }}
+policyPlatformEnv: {{ .Values.config.policyPlatformEnv }}
+policyPlatformUsername: {{ .Values.config.policyPlatformUsername }}
+policyPlatformPassword: {{ .Values.config.policyPlatformPassword }}
+policyClientUsername: {{ .Values.config.policyClientUsername }}
+policyClientPassword: {{ .Values.config.policyClientPassword }}
+
+messageReaderHosts: {{ .Values.config.messageReaderHosts }}
+messageReaderTopic: {{ .Values.config.messageReaderTopic }}
+messageReaderAafUserId: {{ .Values.config.messageReaderAafUserId }}
+messageReaderAafPassword: {{ .Values.config.messageReaderAafPassword }}
+
+sdcUrl: {{ .Values.config.sdcUrl }}
+sdcUsername: {{ .Values.config.sdcUsername }}
+sdcPassword: {{ .Values.config.sdcPassword }}
+sdcONAPInstanceID: {{ .Values.config.sdcONAPInstanceID }}
+
+osdfPlacementUsername: {{ .Values.config.osdfPlacementUsername }}
+osdfPlacementPassword: {{ .Values.config.osdfPlacementPassword }}
diff --git a/kubernetes/oof/templates/NOTES.txt b/kubernetes/oof/templates/NOTES.txt
new file mode 100644
index 0000000..ee1b365
--- /dev/null
+++ b/kubernetes/oof/templates/NOTES.txt
@@ -0,0 +1,33 @@
+# Copyright © 2017 Amdocs, Bell Canada
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+1. Get the application URL by running these commands:
+{{- if .Values.ingress.enabled }}
+{{- range .Values.ingress.hosts }}
+  http://{{ . }}
+{{- end }}
+{{- else if contains "NodePort" .Values.service.type }}
+  export NODE_PORT=$(kubectl get --namespace {{ include "common.namespace" . }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ include "common.fullname" . }})
+  export NODE_IP=$(kubectl get nodes --namespace {{ include "common.namespace" . }} -o jsonpath="{.items[0].status.addresses[0].address}")
+  echo http://$NODE_IP:$NODE_PORT
+{{- else if contains "LoadBalancer" .Values.service.type }}
+     NOTE: It may take a few minutes for the LoadBalancer IP to be available.
+           You can watch the status of by running 'kubectl get svc -w {{ include "common.fullname" . }}'
+  export SERVICE_IP=$(kubectl get svc --namespace {{ include "common.namespace" . }} {{ include "common.fullname" . }} -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
+  echo http://$SERVICE_IP:{{ .Values.service.externalPort }}
+{{- else if contains "ClusterIP" .Values.service.type }}
+  export POD_NAME=$(kubectl get pods --namespace {{ include "common.namespace" . }} -l "app={{ template "so.name" . }},release={{ .Release.Name }}" -o jsonpath="{.items[0].metadata.name}")
+  echo "Visit http://127.0.0.1:8080 to use your application"
+  kubectl port-forward $POD_NAME 8080:{{ .Values.service.internalPort }}
+{{- end }}
diff --git a/kubernetes/message-router/charts/zookeeper/Chart.yaml b/kubernetes/oof/templates/configmap.yaml
similarity index 74%
copy from kubernetes/message-router/charts/zookeeper/Chart.yaml
copy to kubernetes/oof/templates/configmap.yaml
index dd999e5..4ccc7cc 100644
--- a/kubernetes/message-router/charts/zookeeper/Chart.yaml
+++ b/kubernetes/oof/templates/configmap.yaml
@@ -13,7 +13,9 @@
 # limitations under the License.
 
 apiVersion: v1
-description: ONAP Dmaap Zookeeper Service
-name: zookeeper
-version: 2.0.0
-
+kind: ConfigMap
+metadata:
+  name: {{ include "common.fullname" . }}-configmap
+  namespace: {{ include "common.namespace" . }}
+data:
+{{ tpl (.Files.Glob "resources/config/*").AsConfig . | indent 2 }}
\ No newline at end of file
diff --git a/kubernetes/message-router/templates/deployment.yaml b/kubernetes/oof/templates/deployment.yaml
similarity index 70%
copy from kubernetes/message-router/templates/deployment.yaml
copy to kubernetes/oof/templates/deployment.yaml
index ed3c4eb..30a313c 100644
--- a/kubernetes/message-router/templates/deployment.yaml
+++ b/kubernetes/oof/templates/deployment.yaml
@@ -11,6 +11,7 @@
 # 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.
+
 apiVersion: extensions/v1beta1
 kind: Deployment
 metadata:
@@ -34,9 +35,9 @@
         - /root/ready.py
         args:
         - --container-name
-        - {{ .Values.kafka.nameOverride }}
+        - pdp
         - --container-name
-        - {{ .Values.zookeeper.nameOverride }}
+        - oof-has-api
         env:
         - name: NAMESPACE
           valueFrom:
@@ -51,45 +52,49 @@
           image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
-          - containerPort: {{ .Values.service.externalPort }}
-          - containerPort: {{ .Values.service.externalPort2 }}
-          {{- if eq .Values.liveness.enabled true }}
+          - containerPort: {{ .Values.service.internalPort }}
+          # disable liveness probe when breakpoints set in debugger
+          # so K8s doesn't restart unresponsive container
+          {{- if .Values.liveness.enabled }}
           livenessProbe:
             tcpSocket:
-              port: {{ .Values.service.externalPort }}
+              port: {{ .Values.service.internalPort }}
             initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
             periodSeconds: {{ .Values.liveness.periodSeconds }}
           {{ end -}}
           readinessProbe:
             tcpSocket:
-              port: {{ .Values.service.externalPort }}
+              port: {{ .Values.service.internalPort }}
             initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
             periodSeconds: {{ .Values.readiness.periodSeconds }}
+          env:
           volumeMounts:
           - mountPath: /etc/localtime
             name: localtime
             readOnly: true
-          - mountPath: /appl/dmaapMR1/bundleconfig/etc/appprops/MsgRtrApi.properties
-            subPath: MsgRtrApi.properties
-            name: appprops
-          - mountPath: /appl/dmaapMR1/etc/cadi.properties
-            subPath: cadi.properties
-            name: cadi
-          - mountPath: /appl/dmaapMR1/etc/keyfile
-            subPath: mykey
-            name: mykey
+          - mountPath: /opt/app/config/osdf_config.yaml
+            name: {{ include "common.fullname" . }}-config
+            subPath: osdf_config.yaml
+          resources:
+{{ toYaml .Values.resources | indent 12 }}
+        {{- if .Values.nodeSelector }}
+        nodeSelector:
+{{ toYaml .Values.nodeSelector | indent 10 }}
+        {{- end -}}
+        {{- if .Values.affinity }}
+        affinity:
+{{ toYaml .Values.affinity | indent 10 }}
+        {{- end }}
+
       volumes:
         - name: localtime
           hostPath:
             path: /etc/localtime
-        - name: appprops
+        - name: {{ include "common.fullname" . }}-config
           configMap:
-            name: {{ include "common.fullname" . }}-msgrtrapi-prop-configmap
-        - name: cadi
-          configMap:
-            name: {{ include "common.fullname" . }}-cadi-prop-configmap
-        - name: mykey
-          secret:
-            secretName: {{ include "common.fullname" . }}-secret
+            name: {{ include "common.fullname" . }}-configmap
+            items:
+            - key: osdf_config.yaml
+              path: osdf_config.yaml
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/message-router/charts/kafka/templates/service.yaml b/kubernetes/oof/templates/service.yaml
similarity index 69%
copy from kubernetes/message-router/charts/kafka/templates/service.yaml
copy to kubernetes/oof/templates/service.yaml
index c57d190..66a2686 100644
--- a/kubernetes/message-router/charts/kafka/templates/service.yaml
+++ b/kubernetes/oof/templates/service.yaml
@@ -15,18 +15,27 @@
 apiVersion: v1
 kind: Service
 metadata:
-  name: {{ .Values.service.name }}
+  name: {{ include "common.servicename" . }}
   namespace: {{ include "common.namespace" . }}
   labels:
     app: {{ include "common.name" . }}
     chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
     release: {{ .Release.Name }}
     heritage: {{ .Release.Service }}
+  annotations:
 spec:
+  type: {{ .Values.service.type }}
   ports:
+    {{if eq .Values.service.type "NodePort" -}}
+    - port: {{ .Values.service.externalPort }}
+      nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort }}
+      targetPort: {{ .Values.service.internalPort }}
+      name: {{ .Values.service.portName }}
+    {{- else -}}
     - port: {{ .Values.service.externalPort }}
       targetPort: {{ .Values.service.internalPort }}
-      name: {{ .Values.service.name }}
+      name: {{ .Values.service.portName }}
+    {{- end}}
   selector:
     app: {{ include "common.name" . }}
     release: {{ .Release.Name }}
diff --git a/kubernetes/oof/values.yaml b/kubernetes/oof/values.yaml
new file mode 100644
index 0000000..4196cd2
--- /dev/null
+++ b/kubernetes/oof/values.yaml
@@ -0,0 +1,97 @@
+# Copyright © 2017 Amdocs, AT&T, Bell Canada, VMware
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#################################################################
+# Global configuration defaults.
+#################################################################
+global:
+  nodePortPrefix: 302
+  repositorySecret: eyJuZXh1czMub25hcC5vcmc6MTAwMDEiOnsidXNlcm5hbWUiOiJkb2NrZXIiLCJwYXNzd29yZCI6ImRvY2tlciIsImVtYWlsIjoiQCIsImF1dGgiOiJaRzlqYTJWeU9tUnZZMnRsY2c9PSJ9fQ==
+  readinessRepository: oomk8s
+  readinessImage: readiness-check:1.0.0
+  loggingRepository: docker.elastic.co
+  loggingImage: beats/filebeat:5.5.0
+#################################################################
+# Application configuration defaults.
+#################################################################
+# application image
+repository: nexus3.onap.org:10001
+image: onap/optf-osdf:latest
+pullPolicy: Always
+
+# flag to enable debugging - application support required
+debugEnabled: false
+
+# application configuration
+config:
+  msbgateway: msb-iag.{{ include "common.namespace" . }}
+  msbPort: 80
+  # Credentials for the OOF placement service – SO.
+  osdfPlacementSOUsername: so_test
+  osdfPlacementSOPassword: so_testpwd
+  # Credentials for the OOF CM scheduling service – Generic.
+  osdfCMSchedulerUsername: test1
+  osdfCMSchedulerPassword: testpwd1
+  # Credentials of the callback url for SO.
+  soUsername: ""   # SO username for call back.
+  soPassword: ""   # SO password for call back.
+  # Url and credentials for Conductor.
+  conductorUrl: https://oof-has-api.{{ include "common.namespace" . }}:8091/v1/plans/
+  conductorUsername: admin1
+  conductorPassword: plan.15
+  conductorPingWaitTime: 60
+  conductorMaxRetries: 30
+  # Url and credentials for the Policy Platform
+  policyPlatformUrl: http://pdp:8081/pdp/api/getConfig # Policy Dev platform URL
+  policyPlatformEnv: TEST # Environment for policy platform
+  policyPlatformUsername: testpdp # Policy platform username.
+  policyPlatformPassword: alpha123 # Policy platform password.
+  policyClientUsername: python # For use with ClientAuth
+  policyClientPassword: test # For use with ClientAuth
+  # Credentials for the message reader - A placeholder.
+  messageReaderHosts: NA
+  messageReaderTopic: NA
+  messageReaderAafUserId: NA
+  messageReaderAafPassword: NA
+  # Credentials for the SDC interface - A placeholder.
+  sdcUrl: NA
+  sdcUsername: NA
+  sdcPassword: NA
+  sdcONAPInstanceID: NA
+  # Credentials for the placement service – Generic.
+  osdfPlacementUsername: "test"
+  osdfPlacementPassword: "testpwd"
+# default number of instances
+replicaCount: 1
+nodeSelector: {}
+affinity: {}
+# probe configuration parameters
+liveness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+  # necessary to disable liveness probe when setting breakpoints
+  # in debugger so K8s doesn't restart unresponsive container
+  enabled: true
+readiness:
+  initialDelaySeconds: 10
+  periodSeconds: 10
+service:
+  type: NodePort
+  name: oof-osdf
+  externalPort: 8698
+  internalPort: 8699
+  nodePort: 48
+ingress:
+  enabled: false
+resources: {}
diff --git a/kubernetes/policy/charts/brmsgw/templates/deployment.yaml b/kubernetes/policy/charts/brmsgw/templates/deployment.yaml
index e096902..fabef68 100644
--- a/kubernetes/policy/charts/brmsgw/templates/deployment.yaml
+++ b/kubernetes/policy/charts/brmsgw/templates/deployment.yaml
@@ -51,7 +51,7 @@
         - ./do-start.sh
         - brmsgw
         name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         ports:
         - containerPort: {{ .Values.service.externalPort }}
diff --git a/kubernetes/policy/charts/brmsgw/values.yaml b/kubernetes/policy/charts/brmsgw/values.yaml
index 4d6c9fd..8329589 100644
--- a/kubernetes/policy/charts/brmsgw/values.yaml
+++ b/kubernetes/policy/charts/brmsgw/values.yaml
@@ -26,7 +26,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/policy-pe:1.2-SNAPSHOT-latest
+image: onap/policy-pe:1.2.0
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/policy/charts/drools/charts/nexus/templates/deployment.yaml b/kubernetes/policy/charts/drools/charts/nexus/templates/deployment.yaml
index c59ed08..1734952 100644
--- a/kubernetes/policy/charts/drools/charts/nexus/templates/deployment.yaml
+++ b/kubernetes/policy/charts/drools/charts/nexus/templates/deployment.yaml
@@ -40,21 +40,21 @@
           name: nexus-data
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
-          - containerPort: {{ .Values.service.internalPort }}
+          - containerPort: {{ .Values.service.externalPort }}
           {{- if eq .Values.liveness.enabled true }}
           livenessProbe:
             tcpSocket:
-              port: {{ .Values.service.internalPort }}
+              port: {{ .Values.service.externalPort }}
             initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
             periodSeconds: {{ .Values.liveness.periodSeconds }}
           {{ end -}}
           readinessProbe:
             httpGet:
               path: {{ .Values.readiness.path }}
-              port: {{ .Values.service.internalPort }}
+              port: {{ .Values.service.externalPort }}
             initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
             periodSeconds: {{ .Values.readiness.periodSeconds }}
           volumeMounts:
diff --git a/kubernetes/policy/charts/drools/charts/nexus/templates/pv.yaml b/kubernetes/policy/charts/drools/charts/nexus/templates/pv.yaml
index 8be3d4c..da117f4 100644
--- a/kubernetes/policy/charts/drools/charts/nexus/templates/pv.yaml
+++ b/kubernetes/policy/charts/drools/charts/nexus/templates/pv.yaml
@@ -33,5 +33,5 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
 {{- end -}}
diff --git a/kubernetes/policy/charts/drools/charts/nexus/templates/service.yaml b/kubernetes/policy/charts/drools/charts/nexus/templates/service.yaml
index ded4657..594950e 100644
--- a/kubernetes/policy/charts/drools/charts/nexus/templates/service.yaml
+++ b/kubernetes/policy/charts/drools/charts/nexus/templates/service.yaml
@@ -23,10 +23,17 @@
     release: {{ .Release.Name }}
     heritage: {{ .Release.Service }}
 spec:
+  type: {{ .Values.service.type }}
   ports:
-    - port: {{ .Values.service.internalPort }}
+    {{if eq .Values.service.type "NodePort" -}}
+    - port: {{ .Values.service.externalPort }}
+      nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort }}
       name: {{ .Values.service.portName }}
+    {{- else -}}
+    - port: {{ .Values.service.externalPort }}
+      targetPort: {{ .Values.service.internalPort }}
+      name: {{ .Values.service.portName }}
+    {{- end}}
   selector:
     app: {{ include "common.name" . }}
     release: {{ .Release.Name }}
-  clusterIP: None
diff --git a/kubernetes/policy/charts/drools/charts/nexus/values.yaml b/kubernetes/policy/charts/drools/charts/nexus/values.yaml
index 6679876..55b231a 100644
--- a/kubernetes/policy/charts/drools/charts/nexus/values.yaml
+++ b/kubernetes/policy/charts/drools/charts/nexus/values.yaml
@@ -62,7 +62,8 @@
   type: NodePort
   name: nexus
   portName: nexus
-  internalPort: 8081
+  externalPort: 8081
+  nodePort: 36
 
 ingress:
   enabled: false
diff --git a/kubernetes/policy/charts/drools/resources/config/opt/policy/config/drools/drools-preinstall.sh b/kubernetes/policy/charts/drools/resources/config/opt/policy/config/drools/drools-preinstall.sh
new file mode 100644
index 0000000..8b29012
--- /dev/null
+++ b/kubernetes/policy/charts/drools/resources/config/opt/policy/config/drools/drools-preinstall.sh
@@ -0,0 +1,52 @@
+#!/bin/bash
+#
+# ============LICENSE_START=======================================================
+# ONAP
+# ================================================================================
+# Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+# ================================================================================
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============LICENSE_END=========================================================
+#
+
+# #################################
+# Usage
+# #################################
+
+function usage {
+    echo
+    echo "Usage: $(basename $0)"
+    echo
+}
+
+if [[ ${DEBUG} == y ]]; then
+    set -x
+fi
+
+if [[ -z ${BUILD_VERSION} ]]; then
+    echo "no BUILD_VERSION available as environment variable""
+    usage
+    exit 1
+fi
+
+if [[ -z ${POLICY_INSTALL} ]]; then
+    echo "no POLICY_INSTALL available as environment variable""
+    usage
+    exit 2
+fi
+
+CONFIG_DIR=$(dirname "$0")
+echo "invoking ${CONFIG_DIR}/apps-install.sh for controlloop ${BUILD_VERSION} at ${POLICY_INSTALL}"
+export DEBUG=y
+bash ${CONFIG_DIR}/apps-install.sh controlloop ${BUILD_VERSION} ${POLICY_INSTALL}
+unzip -o ${POLICY_INSTALL}/app*.zip -d ${POLICY_INSTALL}
diff --git a/kubernetes/policy/charts/drools/resources/scripts/do-start.sh b/kubernetes/policy/charts/drools/resources/scripts/do-start.sh
deleted file mode 100644
index 1c40e11..0000000
--- a/kubernetes/policy/charts/drools/resources/scripts/do-start.sh
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright © 2017 Amdocs, Bell Canada, AT&T
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-#!/bin/bash
-
-# skip installation if build.info file is present (restarting an existing container)
-if [[ -f /opt/app/policy/etc/build.info ]]; then
-	echo "Found existing installation, will not reinstall"
-	. /opt/app/policy/etc/profile.d/env.sh
-else 
-	# replace conf files from installer with environment-specific files
-	# mounted from the hosting VM
-	if [[ -d config ]]; then
-		cp config/*.conf .
-	fi
-
-	./docker-install.sh
-
-	. /opt/app/policy/etc/profile.d/env.sh
-
-	# install policy keystore
-	mkdir -p $POLICY_HOME/etc/ssl
-	cp config/policy-keystore $POLICY_HOME/etc/ssl
-
-	if [[ -x config/drools-tweaks.sh ]] ; then
-		echo "Executing tweaks"
-		# file may not be executable; running it as an
-		# argument to bash avoids needing execute perms.
-		bash config/drools-tweaks.sh
-	fi
-
-	# sql provisioning scripts should be invoked here.
-fi
-
-echo "Starting processes"
-
-policy start
-
-sleep 1000d
diff --git a/kubernetes/policy/charts/drools/templates/configmap.yaml b/kubernetes/policy/charts/drools/templates/configmap.yaml
index 36f458f..29b1c56 100644
--- a/kubernetes/policy/charts/drools/templates/configmap.yaml
+++ b/kubernetes/policy/charts/drools/templates/configmap.yaml
@@ -31,14 +31,6 @@
 apiVersion: v1
 kind: ConfigMap
 metadata:
-  name: {{ include "common.fullname" . }}-script-configmap
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/scripts/do-start.sh*").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
   name: {{ include "common.fullname" . }}-log-configmap
   namespace: {{ include "common.namespace" . }}
 data:
diff --git a/kubernetes/policy/charts/drools/templates/statefulset.yaml b/kubernetes/policy/charts/drools/templates/statefulset.yaml
index 5dd49ed..9041478 100644
--- a/kubernetes/policy/charts/drools/templates/statefulset.yaml
+++ b/kubernetes/policy/charts/drools/templates/statefulset.yaml
@@ -57,7 +57,7 @@
         - "aai.api.simpledemo.openecomp.org"
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.externalPort }}
@@ -85,9 +85,6 @@
           - mountPath: /etc/localtime
             name: localtime
             readOnly: true
-          - mountPath: /tmp/policy-install/config/policy-keystore
-            name: drools-secret
-            subPath: policy-keystore
           - mountPath: /tmp/policy-install/config/feature-healthcheck.conf
             name: drools-secret
             subPath: feature-healthcheck.conf
@@ -103,6 +100,9 @@
           - mountPath: /tmp/policy-install/config/apps-install.sh
             name: drools-config
             subPath: apps-install.sh
+          - mountPath: /tmp/policy-install/config/drools-preinstall.sh
+            name: drools-config
+            subPath: drools-preinstall.sh
           - mountPath: /usr/share/maven/conf/settings.xml
             name: drools-settingsxml
             subPath: settings.xml
@@ -111,9 +111,6 @@
           - mountPath: /tmp/logback.xml
             name: policy-logback
             subPath: logback.xml
-          - mountPath: /tmp/policy-install/do-start.sh
-            name: pe-scripts
-            subPath: do-start.sh
           lifecycle:
             postStart:
               exec:
@@ -169,19 +166,18 @@
             - key: drools-tweaks.sh
               path: drools-tweaks.sh
               mode: 0755
+            - key: apps-install.sh
+              path: apps-install.sh
+              mode: 0755
+            - key: drools-preinstall.sh
+              path: drools-preinstall.sh
+              mode: 0755
         - name: drools-secret
           secret:
             secretName: {{ include "common.fullname" . }}-secret
             items:
-            - key: policy-keystore
-              path: policy-keystore
-              mode: 0644
             - key: feature-healthcheck.conf
               path: feature-healthcheck.conf
               mode: 0644
-        - name: pe-scripts
-          configMap:
-            name: {{ include "common.fullname" . }}-script-configmap
-            defaultMode: 0777
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/policy/charts/drools/values.yaml b/kubernetes/policy/charts/drools/values.yaml
index c2504a6..9abab85 100644
--- a/kubernetes/policy/charts/drools/values.yaml
+++ b/kubernetes/policy/charts/drools/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/policy-drools:1.2-STAGING-latest
+image: onap/policy-drools:1.2.0
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/policy/charts/mariadb/templates/deployment.yaml b/kubernetes/policy/charts/mariadb/templates/deployment.yaml
index 1709af7..adfebca 100644
--- a/kubernetes/policy/charts/mariadb/templates/deployment.yaml
+++ b/kubernetes/policy/charts/mariadb/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
@@ -41,6 +41,7 @@
           {{- if eq .Values.liveness.enabled true }}
           args:
           - --lower-case-table-names=1
+          - --wait_timeout=28800
           livenessProbe:
             tcpSocket:
               port: {{ .Values.service.internalPort }}
diff --git a/kubernetes/policy/charts/mariadb/templates/pv.yaml b/kubernetes/policy/charts/mariadb/templates/pv.yaml
index 8be3d4c..da117f4 100644
--- a/kubernetes/policy/charts/mariadb/templates/pv.yaml
+++ b/kubernetes/policy/charts/mariadb/templates/pv.yaml
@@ -33,5 +33,5 @@
     - {{ .Values.persistence.accessMode }}
   persistentVolumeReclaimPolicy: {{ .Values.persistence.volumeReclaimPolicy }}
   hostPath:
-    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Namespace }}/{{ .Values.persistence.mountSubPath }}
+    path: {{ .Values.global.persistence.mountPath | default .Values.persistence.mountPath }}/{{ .Release.Name }}/{{ .Values.persistence.mountSubPath }}
 {{- end -}}
diff --git a/kubernetes/policy/charts/mariadb/values.yaml b/kubernetes/policy/charts/mariadb/values.yaml
index eb62715..ea79ba6 100644
--- a/kubernetes/policy/charts/mariadb/values.yaml
+++ b/kubernetes/policy/charts/mariadb/values.yaml
@@ -25,7 +25,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: mariadb:10.0.34
+image: mariadb:10.2.14
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/policy/charts/pdp/templates/service.yaml b/kubernetes/policy/charts/pdp/templates/service.yaml
index d44fbb9..fc608d5 100644
--- a/kubernetes/policy/charts/pdp/templates/service.yaml
+++ b/kubernetes/policy/charts/pdp/templates/service.yaml
@@ -49,4 +49,3 @@
     app: {{ include "common.name" . }}
     release: {{ .Release.Name }}
   sessionAffinity: None
-  clusterIP: None
diff --git a/kubernetes/policy/charts/pdp/templates/statefulset.yaml b/kubernetes/policy/charts/pdp/templates/statefulset.yaml
index 29ded61..7cfc4f0 100644
--- a/kubernetes/policy/charts/pdp/templates/statefulset.yaml
+++ b/kubernetes/policy/charts/pdp/templates/statefulset.yaml
@@ -55,7 +55,7 @@
         - ./do-start.sh
         - pdp
         name: {{ include "common.name" . }}
-        image: {{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         ports:
         - containerPort: {{ .Values.service.externalPort }}
diff --git a/kubernetes/policy/charts/pdp/values.yaml b/kubernetes/policy/charts/pdp/values.yaml
index 3287c9f..f080456 100644
--- a/kubernetes/policy/charts/pdp/values.yaml
+++ b/kubernetes/policy/charts/pdp/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/policy-pe:1.2-SNAPSHOT-latest
+image: onap/policy-pe:1.2.0
 pullPolicy: Always
 
 # flag to enable debugging - application support required
@@ -58,11 +58,11 @@
   periodSeconds: 10
 
 service:
-  type: ClusterIP
+  type: NodePort
   name: pdp
   portName: pdp
-  internalPort: 8081
   externalPort: 8081
+  nodePort: 37
 
 ingress:
   enabled: false
diff --git a/kubernetes/policy/charts/policy-common/resources/config/pe/base.conf b/kubernetes/policy/charts/policy-common/resources/config/pe/base.conf
index ce8a030..c5dd8ca 100644
--- a/kubernetes/policy/charts/policy-common/resources/config/pe/base.conf
+++ b/kubernetes/policy/charts/policy-common/resources/config/pe/base.conf
@@ -18,8 +18,8 @@
 KEYSTORE_PASSWD=Pol1cy_0nap
 
 JDBC_DRIVER=org.mariadb.jdbc.Driver
-JDBC_URL=jdbc:mariadb://{{ .Values.global.mariadb.nameOverride }}:{{.Values.config.mariadbPort}}/onap_sdk?failOverReadOnly=false&autoReconnect=true
-JDBC_LOG_URL=jdbc:mariadb://{{ .Values.global.mariadb.nameOverride }}:{{.Values.config.mariadbPort}}/log?failOverReadOnly=false&autoReconnect=true
+JDBC_URL=jdbc:mariadb://{{ .Values.global.mariadb.nameOverride }}:{{.Values.config.mariadbPort}}/onap_sdk?connectTimeout=30000&socketTimeout=60000&log=true&sessionVariables=max_statement_time=30
+JDBC_LOG_URL=jdbc:mariadb://{{ .Values.global.mariadb.nameOverride }}:{{.Values.config.mariadbPort}}/log?connectTimeout=30000&socketTimeout=60000&log=true&sessionVariables=max_statement_time=30
 JDBC_USER=policy_user
 JDBC_PASSWORD=policy_user
 
diff --git a/kubernetes/policy/templates/deployment.yaml b/kubernetes/policy/templates/deployment.yaml
index 8dca8ab..42a6544 100644
--- a/kubernetes/policy/templates/deployment.yaml
+++ b/kubernetes/policy/templates/deployment.yaml
@@ -51,7 +51,7 @@
           - ./do-start.sh
           - pap
           name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.externalPort }}
diff --git a/kubernetes/policy/values.yaml b/kubernetes/policy/values.yaml
index c2c9747..b708e67 100644
--- a/kubernetes/policy/values.yaml
+++ b/kubernetes/policy/values.yaml
@@ -41,7 +41,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/policy-pe:1.2-STAGING-latest
+image: onap/policy-pe:1.2.0
 pullPolicy: Always
 
 subChartsOnly:
diff --git a/kubernetes/portal/charts/portal-app/templates/deployment.yaml b/kubernetes/portal/charts/portal-app/templates/deployment.yaml
index 7ed8cca..905d52c 100644
--- a/kubernetes/portal/charts/portal-app/templates/deployment.yaml
+++ b/kubernetes/portal/charts/portal-app/templates/deployment.yaml
@@ -47,7 +47,7 @@
               fieldPath: metadata.namespace
       containers:
       - name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         command:
           - /start-apache-tomcat.sh
@@ -136,4 +136,4 @@
         - name: portal-tomcat-logs
           emptyDir: {}
       imagePullSecrets:
-      - name: "{{ include "common.namespace" . }}-docker-registry-key"
\ No newline at end of file
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/portal/charts/portal-cassandra/templates/deployment.yaml b/kubernetes/portal/charts/portal-cassandra/templates/deployment.yaml
index 9e1a57d..6f3f23f 100644
--- a/kubernetes/portal/charts/portal-cassandra/templates/deployment.yaml
+++ b/kubernetes/portal/charts/portal-cassandra/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
       - name: {{ include "common.name" . }}
-        image: {{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         ports:
         - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/portal/charts/portal-mariadb/templates/deployment.yaml b/kubernetes/portal/charts/portal-mariadb/templates/deployment.yaml
index acb26a2..ffb9ef0 100644
--- a/kubernetes/portal/charts/portal-mariadb/templates/deployment.yaml
+++ b/kubernetes/portal/charts/portal-mariadb/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: {{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/portal/charts/portal-sdk/templates/deployment.yaml b/kubernetes/portal/charts/portal-sdk/templates/deployment.yaml
index 3b1d1fd..2d74aae 100644
--- a/kubernetes/portal/charts/portal-sdk/templates/deployment.yaml
+++ b/kubernetes/portal/charts/portal-sdk/templates/deployment.yaml
@@ -47,7 +47,7 @@
               fieldPath: metadata.namespace
       containers:
       - name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         command:
           - /start-apache-tomcat.sh
@@ -127,4 +127,4 @@
         - name: portal-tomcat-logs
           emptyDir: {}
       imagePullSecrets:
-      - name: "{{ include "common.namespace" . }}-docker-registry-key"
\ No newline at end of file
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/portal/charts/portal-widget/templates/deployment.yaml b/kubernetes/portal/charts/portal-widget/templates/deployment.yaml
index 6ce7d4e..6eafd7a 100644
--- a/kubernetes/portal/charts/portal-widget/templates/deployment.yaml
+++ b/kubernetes/portal/charts/portal-widget/templates/deployment.yaml
@@ -47,7 +47,7 @@
               fieldPath: metadata.namespace
       containers:
       - name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         command:
           - /start-wms.sh
@@ -94,4 +94,4 @@
             name: {{ include "common.fullname" . }}-onapwidgetms
             defaultMode: 0755
       imagePullSecrets:
-      - name: "{{ include "common.namespace" . }}-docker-registry-key"
\ No newline at end of file
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/portal/charts/portal-zookeeper/templates/deployment.yaml b/kubernetes/portal/charts/portal-zookeeper/templates/deployment.yaml
index fa891f8..cf93f6b 100644
--- a/kubernetes/portal/charts/portal-zookeeper/templates/deployment.yaml
+++ b/kubernetes/portal/charts/portal-zookeeper/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: {{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/robot/resources/config/eteshare/config/integration_robot_properties.py b/kubernetes/robot/resources/config/eteshare/config/integration_robot_properties.py
index 2235a31..5bfb408 100755
--- a/kubernetes/robot/resources/config/eteshare/config/integration_robot_properties.py
+++ b/kubernetes/robot/resources/config/eteshare/config/integration_robot_properties.py
@@ -18,6 +18,7 @@
 GLOBAL_ASDC_SERVER_PROTOCOL = "http"
 GLOBAL_ASDC_FE_PORT = "8181"
 GLOBAL_ASDC_BE_PORT = "8080"
+GLOBAL_ASDC_BE_ONBOARD_PORT = "8081"
 GLOBAL_ASDC_BE_USERNAME = "beep"
 GLOBAL_ASDC_BE_PASSWORD = "boop"
 # clamp info - everything is from the private oam network (also called onap private network)
@@ -48,6 +49,10 @@
 # music info - everything is from the private oam network (also called onap private network)
 GLOBAL_MUSIC_SERVER_PROTOCOL = "http"
 GLOBAL_MUSIC_SERVER_PORT = "8080"
+# oof
+GLOBAL_OOF_SERVER_PROTOCOL = "http"
+GLOBAL_OOF_HOMING_SERVER_PORT = "8091"
+GLOBAL_OOF_SNIRO_SERVER_PORT = "8698"
 # openstack info - info to select right info in environment
 # packet generate vnf info - everything is from the private oam network (also called onap private network)
 GLOBAL_PACKET_GENERATOR_PORT = "8183"
diff --git a/kubernetes/robot/resources/config/eteshare/config/vm_properties.py b/kubernetes/robot/resources/config/eteshare/config/vm_properties.py
index 7ce15db..bc0544f 100755
--- a/kubernetes/robot/resources/config/eteshare/config/vm_properties.py
+++ b/kubernetes/robot/resources/config/eteshare/config/vm_properties.py
@@ -26,7 +26,9 @@
 GLOBAL_INJECTED_NEXUS_PASSWORD = "docker"
 GLOBAL_INJECTED_NEXUS_REPO = "https://nexus.onap.org/content/sites/raw"
 GLOBAL_INJECTED_NEXUS_USERNAME = "docker"
-GLOBAL_INJECTED_OOF_IP_ADDR = "oof.{{include "common.namespace" .}}"
+GLOBAL_INJECTED_OOF_IP_ADDR = "N/A"
+GLOBAL_INJECTED_OOF_HOMING_IP_ADDR = "oof-has-api.{{include "common.namespace" .}}"
+GLOBAL_INJECTED_OOF_SNIRO_IP_ADDR = "oof-osdf.{{include "common.namespace" .}}"
 GLOBAL_INJECTED_OPENO_IP_ADDR = "msb-iag.{{include "common.namespace" .}}"
 GLOBAL_INJECTED_OPENSTACK_PASSWORD = "{{ .Values.openStackPassword }}"
 GLOBAL_INJECTED_OPENSTACK_TENANT_ID = "{{ .Values.openStackTenantId }}"
@@ -39,6 +41,7 @@
 GLOBAL_INJECTED_REMOTE_REPO = "http://gerrit.onap.org/r/testsuite/properties.git"
 GLOBAL_INJECTED_SCRIPT_VERSION = "{{ .Values.scriptVersion }}"
 GLOBAL_INJECTED_SDC_BE_IP_ADDR = "sdc-be.{{include "common.namespace" .}}"
+GLOBAL_INJECTED_SDC_BE_ONBOARD_IP_ADDR = "sdc-onboarding-be.{{include "common.namespace" .}}"
 GLOBAL_INJECTED_SDC_FE_IP_ADDR = "sdc-fe.{{include "common.namespace" .}}"
 GLOBAL_INJECTED_SDC_IP_ADDR = "N/A"
 GLOBAL_INJECTED_SDNC_IP_ADDR = "sdnc.{{include "common.namespace" .}}"
@@ -77,7 +80,9 @@
     "GLOBAL_INJECTED_NEXUS_PASSWORD" : "docker",
     "GLOBAL_INJECTED_NEXUS_REPO" : "https://nexus.onap.org/content/sites/raw",
     "GLOBAL_INJECTED_NEXUS_USERNAME" : "docker",
-    "GLOBAL_INJECTED_OOF_IP_ADDR" : "oof.{{include "common.namespace" .}}",
+    "GLOBAL_INJECTED_OOF_IP_ADDR" : "N/A",
+    "GLOBAL_INJECTED_OOF_HOMING_IP_ADDR" : "oof-has-api.{{include "common.namespace" .}}",
+    "GLOBAL_INJECTED_OOF_SNIRO_IP_ADDR" : "oof-osdf.{{include "common.namespace" .}}",
     "GLOBAL_INJECTED_OPENO_IP_ADDR" : "msb-iag.{{include "common.namespace" .}}",
     "GLOBAL_INJECTED_OPENSTACK_PASSWORD" : "{{ .Values.openStackEncryptedPassword }}",
     "GLOBAL_INJECTED_OPENSTACK_TENANT_ID" : "{{ .Values.openStackTenantId }}",
@@ -89,6 +94,7 @@
     "GLOBAL_INJECTED_REGION" : "{{ .Values.openStackRegion }}",
     "GLOBAL_INJECTED_REMOTE_REPO" : "http://gerrit.onap.org/r/testsuite/properties.git",
     "GLOBAL_INJECTED_SDC_BE_IP_ADDR" : "sdc-be.{{include "common.namespace" .}}",
+    "GLOBAL_INJECTED_SDC_BE_ONBOARD_IP_ADDR" : "sdc-onboarding-be.{{include "common.namespace" .}}",
     "GLOBAL_INJECTED_SDC_FE_IP_ADDR" : "sdc-fe.{{include "common.namespace" .}}",
     "GLOBAL_INJECTED_SDC_IP_ADDR" : "N/A",
     "GLOBAL_INJECTED_SCRIPT_VERSION" : "{{ .Values.scriptVersion }}",
diff --git a/kubernetes/robot/resources/config/robot/resources/oof_interface.robot b/kubernetes/robot/resources/config/robot/resources/oof_interface.robot
new file mode 100644
index 0000000..1c3137e
--- /dev/null
+++ b/kubernetes/robot/resources/config/robot/resources/oof_interface.robot
@@ -0,0 +1,41 @@
+*** Settings ***
+Documentation     The main interface for interacting with OOF: SNIRO and Homing Service
+Library           RequestsLibrary
+
+Resource          global_properties.robot
+
+*** Variables ***
+${OOF_HOMING_HEALTH_CHECK_PATH}       /v1/plans/healthcheck
+${OOF_SNIRO_HEALTH_CHECK_PATH}        /api/oof/v1/healthcheck
+
+${OOF_HOMING_ENDPOINT}    ${GLOBAL_OOF_SERVER_PROTOCOL}://${GLOBAL_INJECTED_OOF_HOMING_IP_ADDR}:${GLOBAL_OOF_HOMING_SERVER_PORT}
+${OOF_SNIRO_ENDPOINT}     ${GLOBAL_OOF_SERVER_PROTOCOL}://${GLOBAL_INJECTED_OOF_SNIRO_IP_ADDR}:${GLOBAL_OOF_SNIRO_SERVER_PORT}
+
+*** Keywords ***
+Run OOF-Homing Health Check
+     [Documentation]    Runs OOF-Homing Health check
+     ${resp}=    Run OOF-Homing Get Request    ${OOF_HOMING_HEALTH_CHECK_PATH}
+     Should Be Equal As Integers   ${resp.status_code}   200
+
+Run OOF-Homing Get Request
+     [Documentation]    Runs OOF-Homing Get request
+     [Arguments]    ${data_path}
+     ${session}=    Create Session   session   ${OOF_HOMING_ENDPOINT}
+     ${resp}=   Get Request   session   ${data_path}
+     Should Be Equal As Integers   ${resp.status_code}   200
+     Log    Received response from OOF-Homing ${resp.text}
+     [Return]    ${resp}
+ 
+Run OOF-SNIRO Health Check
+     [Documentation]    Runs OOF-SNIRO Health check
+     ${resp}=    Run OOF-SNIRO Get Request    ${OOF_SNIRO_HEALTH_CHECK_PATH}
+     Should Be Equal As Integers   ${resp.status_code}   200
+
+Run OOF-SNIRO Get Request
+     [Documentation]    Runs OOF-SNIRO Get request
+     [Arguments]    ${data_path}
+     ${session}=    Create Session   session   ${OOF_SNIRO_ENDPOINT}
+     ${resp}=   Get Request   session   ${data_path}
+     Should Be Equal As Integers   ${resp.status_code}   200
+     Log    Received response from OOF-SNIRO ${resp.text}
+     [Return]    ${resp}
diff --git a/kubernetes/robot/templates/deployment.yaml b/kubernetes/robot/templates/deployment.yaml
index 6379aa1..0b65809 100644
--- a/kubernetes/robot/templates/deployment.yaml
+++ b/kubernetes/robot/templates/deployment.yaml
@@ -75,6 +75,9 @@
         - name: robot-resources
           mountPath: /var/opt/OpenECOMP_ETE/robot/resources/sdngc_interface.robot
           subPath: sdngc_interface.robot
+        - name: robot-resources
+          mountPath: /var/opt/OpenECOMP_ETE/robot/resources/oof_interface.robot
+          subPath: oof_interface.robot         
         - name: robot-lighttpd-authorization
           mountPath: /etc/lighttpd/authorization
           subPath: authorization
diff --git a/kubernetes/sdnc/charts/dmaap-listener/templates/deployment.yaml b/kubernetes/sdnc/charts/dmaap-listener/templates/deployment.yaml
index 733b21e..db32362 100644
--- a/kubernetes/sdnc/charts/dmaap-listener/templates/deployment.yaml
+++ b/kubernetes/sdnc/charts/dmaap-listener/templates/deployment.yaml
@@ -53,7 +53,7 @@
       - command:
         - /opt/onap/sdnc/dmaap-listener/bin/start-dmaap-listener.sh
         name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         env:
         - name: PROPERTY_DIR
@@ -86,4 +86,4 @@
           configMap:
             name: sdnc-dmaap-configmap
       imagePullSecrets:
-      - name: "{{ include "common.namespace" . }}-docker-registry-key"
\ No newline at end of file
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/sdnc/charts/sdnc-portal/resources/config/admportal.json b/kubernetes/sdnc/charts/sdnc-portal/resources/config/admportal.json
index afd8721..3e87321 100644
--- a/kubernetes/sdnc/charts/sdnc-portal/resources/config/admportal.json
+++ b/kubernetes/sdnc/charts/sdnc-portal/resources/config/admportal.json
@@ -39,8 +39,8 @@
   "dbPassword": "gamma",
   "dbName": "sdnctl",
   "odlProtocol": "http",
-  "odlHost": "{{.Release.Name}}-sdnc.{{.Release.Namespace}}",
-  "odlConexusHost": "{{.Release.Name}}-sdnc.{{.Release.Namespace}}",
+  "odlHost": "sdnc.{{.Release.Namespace}}",
+  "odlConexusHost": "sdnc.{{.Release.Namespace}}",
   "odlPort": "8181",
   "odlConexusPort": "8181",
   "odlUser": "admin",
diff --git a/kubernetes/sdnc/charts/sdnc-portal/templates/deployment.yaml b/kubernetes/sdnc/charts/sdnc-portal/templates/deployment.yaml
index 3ca8a6b..b456d8e 100644
--- a/kubernetes/sdnc/charts/sdnc-portal/templates/deployment.yaml
+++ b/kubernetes/sdnc/charts/sdnc-portal/templates/deployment.yaml
@@ -51,7 +51,7 @@
         - name: {{ include "common.name" . }}
           command: ["/bin/bash"]
           args: ["-c", "cd /opt/onap/sdnc/admportal/shell && ./start_portal.sh"]
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
@@ -101,4 +101,4 @@
           configMap:
             name: {{ include "common.fullname" . }}-portal
       imagePullSecrets:
-      - name: "{{ include "common.namespace" . }}-docker-registry-key"
\ No newline at end of file
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/sdnc/charts/ueb-listener/resources/config/ueb-listener.properties b/kubernetes/sdnc/charts/ueb-listener/resources/config/ueb-listener.properties
index cd184bf..a91ad94 100644
--- a/kubernetes/sdnc/charts/ueb-listener/resources/config/ueb-listener.properties
+++ b/kubernetes/sdnc/charts/ueb-listener/resources/config/ueb-listener.properties
@@ -6,7 +6,7 @@
 org.onap.ccsdk.sli.northbound.uebclient.user=sdnc
 org.onap.ccsdk.sli.northbound.uebclient.sdnc-user=admin
 org.onap.ccsdk.sli.northbound.uebclient.sdnc-passwd=Kp8bJ4SXszM0WXlhak3eHlcse2gAw84vaoGGmJvUy2U
-org.onap.ccsdk.sli.northbound.uebclient.asdc-api-base-url=http://sdnhost.{{.Release.Namespace}}:8282/restconf/operations/
+org.onap.ccsdk.sli.northbound.uebclient.asdc-api-base-url=http://sdnc.{{.Release.Namespace}}:8282/restconf/operations/
 org.onap.ccsdk.sli.northbound.uebclient.asdc-api-namespace=org:onap:ccsdk
 org.onap.ccsdk.sli.northbound.uebclient.spool.incoming=/opt/onap/sdnc/ueb-listener/spool/incoming
 org.onap.ccsdk.sli.northbound.uebclient.spool.archive=/opt/onap/sdnc/ueb-listener/spool/archive
diff --git a/kubernetes/sdnc/charts/ueb-listener/templates/configmap.yaml b/kubernetes/sdnc/charts/ueb-listener/templates/configmap.yaml
index 397303f..fd8934b 100644
--- a/kubernetes/sdnc/charts/ueb-listener/templates/configmap.yaml
+++ b/kubernetes/sdnc/charts/ueb-listener/templates/configmap.yaml
@@ -15,7 +15,7 @@
 apiVersion: v1
 kind: ConfigMap
 metadata:
-  name: sdnc-ueb-configmap
+  name: {{ include "common.fullname" . }}
   namespace: {{ include "common.namespace" . }}
 data:
 {{ tpl (.Files.Glob "resources/config/*").AsConfig . | indent 2 }}
diff --git a/kubernetes/sdnc/charts/ueb-listener/templates/deployment.yaml b/kubernetes/sdnc/charts/ueb-listener/templates/deployment.yaml
index e3f324e..4348039 100644
--- a/kubernetes/sdnc/charts/ueb-listener/templates/deployment.yaml
+++ b/kubernetes/sdnc/charts/ueb-listener/templates/deployment.yaml
@@ -55,7 +55,7 @@
       - command:
         - /opt/onap/sdnc/ueb-listener/bin/start-ueb-listener.sh
         name: {{ include "common.name" . }}
-        image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         env:
         - name: PROPERTY_DIR
@@ -66,9 +66,8 @@
         - mountPath: /etc/localtime
           name: localtime
           readOnly: true
-        - mountPath: /opt/onap/sdnc/data/properties/ueb-listener.properties
-          subPath: ueb-listener.properties
-          name: ueb-config
+        - mountPath: {{ .Values.config.configDir }}
+          name: {{ include "common.fullname" . }}
         resources:
 {{ toYaml .Values.resources | indent 12 }}
         {{- if .Values.nodeSelector }}
@@ -84,8 +83,8 @@
         - name: localtime
           hostPath:
             path: /etc/localtime
-        - name: ueb-config
+        - name: {{ include "common.fullname" . }}
           configMap:
-            name: sdnc-ueb-configmap
+            name: {{ include "common.fullname" . }}
       imagePullSecrets:
-      - name: "{{ include "common.namespace" . }}-docker-registry-key"
\ No newline at end of file
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/sdnc/charts/ueb-listener/values.yaml b/kubernetes/sdnc/charts/ueb-listener/values.yaml
index a6722eb..f31594e 100644
--- a/kubernetes/sdnc/charts/ueb-listener/values.yaml
+++ b/kubernetes/sdnc/charts/ueb-listener/values.yaml
@@ -37,7 +37,7 @@
 # application configuration
 config:
   uebPort: 3904
-  mysqlChartName: sdnc-dbhost
+  mysqlChartName: sdnc-db
   sdncChartName: sdnc
   sdcbeChartName: sdc-be
   msgRouterContainerName: dmaap
diff --git a/kubernetes/sdnc/resources/config/conf/aaiclient.properties b/kubernetes/sdnc/resources/config/conf/aaiclient.properties
index b5d1560..24e74f0 100755
--- a/kubernetes/sdnc/resources/config/conf/aaiclient.properties
+++ b/kubernetes/sdnc/resources/config/conf/aaiclient.properties
@@ -40,106 +40,106 @@
 #
 # Configuration file for A&AI Client
 #
-org.onap.ccsdk.sli.adaptors.aai.uri=https://aai-service.{{.Release.Namespace}}:8443
+org.onap.ccsdk.sli.adaptors.aai.uri=https://aai.{{.Release.Namespace}}:8443
 
 
 # query
-org.onap.ccsdk.sli.adaptors.aai.path.query=/aai/v11/search/sdn-zone-query
-org.onap.ccsdk.sli.adaptors.aai.query.nodes=/aai/v11/search/nodes-query?search-node-type={node-type}&filter={entity-identifier}:EQUALS:{entity-name}
-org.onap.ccsdk.sli.adaptors.aai.query.generic=/aai/v11/search/generic-query?key={identifier}:{value}&start-node-type={start-node-type}&include=complex&depth=3
+org.onap.ccsdk.sli.adaptors.aai.path.query=/aai/v13/search/sdn-zone-query
+org.onap.ccsdk.sli.adaptors.aai.query.nodes=/aai/v13/search/nodes-query?search-node-type={node-type}&filter={entity-identifier}:EQUALS:{entity-name}
+org.onap.ccsdk.sli.adaptors.aai.query.generic=/aai/v13/search/generic-query?key={identifier}:{value}&start-node-type={start-node-type}&include=complex&depth=3
 
 # named query
 org.onap.ccsdk.sli.adaptors.aai.query.named=/aai/search/named-query
 
 
 #update
-org.onap.ccsdk.sli.adaptors.aai.update=/aai/v11/actions/update
+org.onap.ccsdk.sli.adaptors.aai.update=/aai/v13/actions/update
 
 # vce
-org.onap.ccsdk.sli.adaptors.aai.path.vce =/aai/v11/network/vces/vce/
-org.onap.ccsdk.sli.adaptors.aai.path.vces=/aai/v11/network/vces/
+org.onap.ccsdk.sli.adaptors.aai.path.vce =/aai/v13/network/vces/vce/
+org.onap.ccsdk.sli.adaptors.aai.path.vces=/aai/v13/network/vces/
 
 # vpe
-org.onap.ccsdk.sli.adaptors.aai.path.vpe =/aai/v11/network/vpes/vpe/
-org.onap.ccsdk.sli.adaptors.aai.path.vpes=/aai/v11/network/vpes/
+org.onap.ccsdk.sli.adaptors.aai.path.vpe =/aai/v13/network/vpes/vpe/
+org.onap.ccsdk.sli.adaptors.aai.path.vpes=/aai/v13/network/vpes/
 
 # customer
-org.onap.ccsdk.sli.adaptors.aai.path.customer=/aai/v11/business/customers/customer/{customer-id}
+org.onap.ccsdk.sli.adaptors.aai.path.customer=/aai/v13/business/customers/customer/{customer-id}
 
 # service subscription
-org.onap.ccsdk.sli.adaptors.aai.path.service.subscription=/aai/v11/business/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}
+org.onap.ccsdk.sli.adaptors.aai.path.service.subscription=/aai/v13/business/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}
 
 # service instance
-org.onap.ccsdk.sli.adaptors.aai.path.svcinst=/aai/v11/business/customers/customer/{customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances
-org.onap.ccsdk.sli.adaptors.aai.path.svcinst.query=/aai/v11/search/generic-query?key=service-instance.service-instance-id:{svc-instance-id}&start-node-type=service-instance&include=service-instance
-org.onap.ccsdk.sli.adaptors.aai.path.service.instance=/aai/v11/business/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances/service-instance/{service-instance-id}
+org.onap.ccsdk.sli.adaptors.aai.path.svcinst=/aai/v13/business/customers/customer/{customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances
+org.onap.ccsdk.sli.adaptors.aai.path.svcinst.query=/aai/v13/search/generic-query?key=service-instance.service-instance-id:{svc-instance-id}&start-node-type=service-instance&include=service-instance
+org.onap.ccsdk.sli.adaptors.aai.path.service.instance=/aai/v13/business/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances/service-instance/{service-instance-id}
 
 # complex
-org.onap.ccsdk.sli.adaptors.aai.path.complexes=/aai/v11/cloud-infrastructure/complexes
-org.onap.ccsdk.sli.adaptors.aai.path.complex=/aai/v11/cloud-infrastructure/complexes/complex/{physical-location-id}
+org.onap.ccsdk.sli.adaptors.aai.path.complexes=/aai/v13/cloud-infrastructure/complexes
+org.onap.ccsdk.sli.adaptors.aai.path.complex=/aai/v13/cloud-infrastructure/complexes/complex/{physical-location-id}
 
 # tenant
-org.onap.ccsdk.sli.adaptors.aai.path.tenant=/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/tenants/tenant/{tenant-id}
-org.onap.ccsdk.sli.adaptors.aai.path.tenant.query=/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/tenants/tenant?tenant-name={tenant-name}
+org.onap.ccsdk.sli.adaptors.aai.path.tenant=/aai/v13/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/tenants/tenant/{tenant-id}
+org.onap.ccsdk.sli.adaptors.aai.path.tenant.query=/aai/v13/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/tenants/tenant?tenant-name={tenant-name}
 
 # vservers
-org.onap.ccsdk.sli.adaptors.aai.path.vservers=/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/tenants/tenant/{tenant-id}/vservers/
-org.onap.ccsdk.sli.adaptors.aai.path.vserver=/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/tenants/tenant/{tenant-id}/vservers/vserver/{vserver-id}
+org.onap.ccsdk.sli.adaptors.aai.path.vservers=/aai/v13/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/tenants/tenant/{tenant-id}/vservers/
+org.onap.ccsdk.sli.adaptors.aai.path.vserver=/aai/v13/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/tenants/tenant/{tenant-id}/vservers/vserver/{vserver-id}
 
 # vpls-pe
-org.onap.ccsdk.sli.adaptors.aai.path.vpls.pes=/aai/v11/network/vpls-pes/
-org.onap.ccsdk.sli.adaptors.aai.path.vpls.pe =/aai/v11/network/vpls-pes/vpls-pe/
+org.onap.ccsdk.sli.adaptors.aai.path.vpls.pes=/aai/v13/network/vpls-pes/
+org.onap.ccsdk.sli.adaptors.aai.path.vpls.pe =/aai/v13/network/vpls-pes/vpls-pe/
 
 # ctag-pool
-org.onap.ccsdk.sli.adaptors.aai.path.ctag.pools=/aai/v11/cloud-infrastructure/complexes/complex/{physical-location-id}/ctag-pools
-org.onap.ccsdk.sli.adaptors.aai.path.ctag.pool=/aai/v11/cloud-infrastructure/complexes/complex/{physical-location-id}/ctag-pools/ctag-pool/{target-pe}/{availability-zone-name}
+org.onap.ccsdk.sli.adaptors.aai.path.ctag.pools=/aai/v13/cloud-infrastructure/complexes/complex/{physical-location-id}/ctag-pools
+org.onap.ccsdk.sli.adaptors.aai.path.ctag.pool=/aai/v13/cloud-infrastructure/complexes/complex/{physical-location-id}/ctag-pools/ctag-pool/{target-pe}/{availability-zone-name}
 
 #
 #-------------- 1510 ----------------------
 #
 
 # pservers
-org.onap.ccsdk.sli.adaptors.aai.path.pservers=/aai/v11/cloud-infrastructure/pservers
-org.onap.ccsdk.sli.adaptors.aai.path.pserver=/aai/v11/cloud-infrastructure/pservers/pserver/{hostname}
+org.onap.ccsdk.sli.adaptors.aai.path.pservers=/aai/v13/cloud-infrastructure/pservers
+org.onap.ccsdk.sli.adaptors.aai.path.pserver=/aai/v13/cloud-infrastructure/pservers/pserver/{hostname}
 
 # generic-vnf
-org.onap.ccsdk.sli.adaptors.aai.path.generic.vnfs=/aai/v11/network/generic-vnfs
-org.onap.ccsdk.sli.adaptors.aai.path.generic.vnf=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}
+org.onap.ccsdk.sli.adaptors.aai.path.generic.vnfs=/aai/v13/network/generic-vnfs
+org.onap.ccsdk.sli.adaptors.aai.path.generic.vnf=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}
 
 # dvs-switch
-org.onap.ccsdk.sli.adaptors.aai.path.dvsswitches=/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/dvs-switches
-org.onap.ccsdk.sli.adaptors.aai.path.dvsswitch=/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/dvs-switches/dvs-switch/{switch-name}
+org.onap.ccsdk.sli.adaptors.aai.path.dvsswitches=/aai/v13/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/dvs-switches
+org.onap.ccsdk.sli.adaptors.aai.path.dvsswitch=/aai/v13/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/dvs-switches/dvs-switch/{switch-name}
 
 # L3 Networks
-org.onap.ccsdk.sli.adaptors.aai.path.l3networks=/aai/v11/network/l3-networks
-org.onap.ccsdk.sli.adaptors.aai.path.l3network=/aai/v11/network/l3-networks/l3-network/{network-id}
-org.onap.ccsdk.sli.adaptors.aai.path.l3network.query.name=/aai/v11/network/l3-networks/l3-network?network-name={network-name}
+org.onap.ccsdk.sli.adaptors.aai.path.l3networks=/aai/v13/network/l3-networks
+org.onap.ccsdk.sli.adaptors.aai.path.l3network=/aai/v13/network/l3-networks/l3-network/{network-id}
+org.onap.ccsdk.sli.adaptors.aai.path.l3network.query.name=/aai/v13/network/l3-networks/l3-network?network-name={network-name}
 
 # P-Interfaces
-org.onap.ccsdk.sli.adaptors.aai.path.pserver.pinterfaces=/aai/v11/cloud-infrastructure/pservers/pserver/{hostname}/p-interfaces
-org.onap.ccsdk.sli.adaptors.aai.path.pserver.pinterface=/aai/v11/cloud-infrastructure/pservers/pserver/{hostname}/p-interfaces/p-interface/{interface-name}
+org.onap.ccsdk.sli.adaptors.aai.path.pserver.pinterfaces=/aai/v13/cloud-infrastructure/pservers/pserver/{hostname}/p-interfaces
+org.onap.ccsdk.sli.adaptors.aai.path.pserver.pinterface=/aai/v13/cloud-infrastructure/pservers/pserver/{hostname}/p-interfaces/p-interface/{interface-name}
 
 # Physical Link
-org.onap.ccsdk.sli.adaptors.aai.path.physical.links=/aai/v11/network/physical-links
-org.onap.ccsdk.sli.adaptors.aai.path.physical.link=/aai/v11/network/physical-links/physical-link/{link-name}
+org.onap.ccsdk.sli.adaptors.aai.path.physical.links=/aai/v13/network/physical-links
+org.onap.ccsdk.sli.adaptors.aai.path.physical.link=/aai/v13/network/physical-links/physical-link/{link-name}
 
 # VPN Bindings
-org.onap.ccsdk.sli.adaptors.aai.path.vpn.bindings=/aai/v11/network/vpn-bindings/
-org.onap.ccsdk.sli.adaptors.aai.path.vpn.binding=/aai/v11/network/vpn-bindings/vpn-binding/{vpn-id}
+org.onap.ccsdk.sli.adaptors.aai.path.vpn.bindings=/aai/v13/network/vpn-bindings/
+org.onap.ccsdk.sli.adaptors.aai.path.vpn.binding=/aai/v13/network/vpn-bindings/vpn-binding/{vpn-id}
 
 # VNF IMAGES
-org.onap.ccsdk.sli.adaptors.aai.path.vnf.images=/aai/v11/service-design-and-creation/vnf-images
-org.onap.ccsdk.sli.adaptors.aai.path.vnf.image=/aai/v11/service-design-and-creation/vnf-images/vnf-image/{att-uuid}
-org.onap.ccsdk.sli.adaptors.aai.path.vnf.image.query=/aai/v11/service-design-and-creation/vnf-images/vnf-image?application={application_model}&application-vendor={application_vendor}
+org.onap.ccsdk.sli.adaptors.aai.path.vnf.images=/aai/v13/service-design-and-creation/vnf-images
+org.onap.ccsdk.sli.adaptors.aai.path.vnf.image=/aai/v13/service-design-and-creation/vnf-images/vnf-image/{att-uuid}
+org.onap.ccsdk.sli.adaptors.aai.path.vnf.image.query=/aai/v13/service-design-and-creation/vnf-images/vnf-image?application={application_model}&application-vendor={application_vendor}
 
 # UBB Notify
-org.onap.ccsdk.sli.adaptors.aai.path.notify=/aai/v11/actions/notify
-org.onap.ccsdk.sli.adaptors.aai.notify.selflink.fqdn=https://aai-service.{{.Release.Namespace}}:8443/restconf/config/L3SDN-API:services/layer3-service-list/{service-instance-id}
-org.onap.ccsdk.sli.adaptors.aai.notify.selflink.avpn=https://aai-service.{{.Release.Namespace}}:8543/restconf/config/L3AVPN-EVC-API:services/service-list/{service-instance-id}/service-data/avpn-logicalchannel-information
+org.onap.ccsdk.sli.adaptors.aai.path.notify=/aai/v13/actions/notify
+org.onap.ccsdk.sli.adaptors.aai.notify.selflink.fqdn=https://aai.{{.Release.Namespace}}:8443/restconf/config/L3SDN-API:services/layer3-service-list/{service-instance-id}
+org.onap.ccsdk.sli.adaptors.aai.notify.selflink.avpn=https://aai.{{.Release.Namespace}}:8543/restconf/config/L3AVPN-EVC-API:services/service-list/{service-instance-id}/service-data/avpn-logicalchannel-information
 
 # Service
-org.onap.ccsdk.sli.adaptors.aai.path.service=/aai/v11/service-design-and-creation/services/service/{service-id}
-org.onap.ccsdk.sli.adaptors.aai.path.services=/aai/v11/service-design-and-creation/services
+org.onap.ccsdk.sli.adaptors.aai.path.service=/aai/v13/service-design-and-creation/services/service/{service-id}
+org.onap.ccsdk.sli.adaptors.aai.path.services=/aai/v13/service-design-and-creation/services
 
 
 #
@@ -147,98 +147,98 @@
 #
 
 # VNFC
-org.onap.ccsdk.sli.adaptors.aai.path.vnfc=/aai/v11/network/vnfcs/vnfc/{vnfc-name}
+org.onap.ccsdk.sli.adaptors.aai.path.vnfc=/aai/v13/network/vnfcs/vnfc/{vnfc-name}
 
 # class-of-service
-org.onap.ccsdk.sli.adaptors.aai.path.class.of.service=/aai/v11/network/site-pair-sets/site-pair-set/{site-pair-set-id}/routing-instances/routing-instance/{routing-instance-id}/site-pairs/site-pair/{site-pair-id}/classes-of-service/class-of-service/{cos-id}
+org.onap.ccsdk.sli.adaptors.aai.path.class.of.service=/aai/v13/network/site-pair-sets/site-pair-set/{site-pair-set-id}/routing-instances/routing-instance/{routing-instance-id}/site-pairs/site-pair/{site-pair-id}/classes-of-service/class-of-service/{cos-id}
 
 # site-pair
-org.onap.ccsdk.sli.adaptors.aai.path.site.pair=/aai/v11/network/site-pair-sets/site-pair-set/{site-pair-set-id}/routing-instances/routing-instance/{routing-instance-id}/site-pairs/site-pair/{site-pair-id}
+org.onap.ccsdk.sli.adaptors.aai.path.site.pair=/aai/v13/network/site-pair-sets/site-pair-set/{site-pair-set-id}/routing-instances/routing-instance/{routing-instance-id}/site-pairs/site-pair/{site-pair-id}
 
 # routing-instance
-org.onap.ccsdk.sli.adaptors.aai.path.routing.instance=/aai/v11/network/site-pair-sets/site-pair-set/{site-pair-set-id}/routing-instances/routing-instance/{routing-instance-id}
+org.onap.ccsdk.sli.adaptors.aai.path.routing.instance=/aai/v13/network/site-pair-sets/site-pair-set/{site-pair-set-id}/routing-instances/routing-instance/{routing-instance-id}
 
 # site-pair-set
-org.onap.ccsdk.sli.adaptors.aai.path.site.pair.set=/aai/v11/network/site-pair-sets/site-pair-set/{site-pair-set-id}
+org.onap.ccsdk.sli.adaptors.aai.path.site.pair.set=/aai/v13/network/site-pair-sets/site-pair-set/{site-pair-set-id}
 
 # license key resource
-org.onap.ccsdk.sli.adaptors.aai.path.license.acquire=/aai/v11/actions/assignment/license-management/assignment-group-uuid/{assignment-group-uuid}
-org.onap.ccsdk.sli.adaptors.aai.path.license=/aai/v11/license-management/license-key-resources/license-key-resource/{att-uuid}
+org.onap.ccsdk.sli.adaptors.aai.path.license.acquire=/aai/v13/actions/assignment/license-management/assignment-group-uuid/{assignment-group-uuid}
+org.onap.ccsdk.sli.adaptors.aai.path.license=/aai/v13/license-management/license-key-resources/license-key-resource/{att-uuid}
 
 # logical-link
-org.onap.ccsdk.sli.adaptors.aai.path.logical.link =/aai/v11/network/logical-links/logical-link/{link-name}
+org.onap.ccsdk.sli.adaptors.aai.path.logical.link =/aai/v13/network/logical-links/logical-link/{link-name}
 
 # virtual-data-center
-org.onap.ccsdk.sli.adaptors.aai.path.virtual.data.center=/aai/v11/cloud-infrastructure/virtual-data-centers/virtual-data-center/{vdc-id}
+org.onap.ccsdk.sli.adaptors.aai.path.virtual.data.center=/aai/v13/cloud-infrastructure/virtual-data-centers/virtual-data-center/{vdc-id}
 
 # wan-connector
-org.onap.ccsdk.sli.adaptors.aai.path.wan.connector=/aai/v11/business/connectors/connector/{resource-instance-id}
+org.onap.ccsdk.sli.adaptors.aai.path.wan.connector=/aai/v13/business/connectors/connector/{resource-instance-id}
 
 # l-interface
-org.onap.ccsdk.sli.adaptors.aai.path.lag.interface.l.interface=/aai/v11/cloud-infrastructure/pservers/pserver/{hostname}/lag-interfaces/lag-interface/{lag-interface.interface-name}/l-interfaces/l-interface/{interface-name}
-org.onap.ccsdk.sli.adaptors.aai.path.p.interface.l.interface=/aai/v11/cloud-infrastructure/pservers/pserver/{hostname}/p-interfaces/p-interface/{p-interface.interface-name}/l-interfaces/l-interface/{interface-name}
+org.onap.ccsdk.sli.adaptors.aai.path.lag.interface.l.interface=/aai/v13/cloud-infrastructure/pservers/pserver/{hostname}/lag-interfaces/lag-interface/{lag-interface.interface-name}/l-interfaces/l-interface/{interface-name}
+org.onap.ccsdk.sli.adaptors.aai.path.p.interface.l.interface=/aai/v13/cloud-infrastructure/pservers/pserver/{hostname}/p-interfaces/p-interface/{p-interface.interface-name}/l-interfaces/l-interface/{interface-name}
 
 # l-interface pnf
-org.onap.ccsdk.sli.adaptors.aai.path.lag.interface.l.interface.pnf=/aai/v11/network/pnfs/pnf/{pnf-name}/lag-interfaces/lag-interface/{lag-interface.interface-name}/l-interfaces/l-interface/{interface-name}
-org.onap.ccsdk.sli.adaptors.aai.path.p.interface.l.interface.pnf=/aai/v11/network/pnfs/pnf/{pnf-name}/p-interfaces/p-interface/{p-interface.interface-name}/l-interfaces/l-interface/{interface-name}
+org.onap.ccsdk.sli.adaptors.aai.path.lag.interface.l.interface.pnf=/aai/v13/network/pnfs/pnf/{pnf-name}/lag-interfaces/lag-interface/{lag-interface.interface-name}/l-interfaces/l-interface/{interface-name}
+org.onap.ccsdk.sli.adaptors.aai.path.p.interface.l.interface.pnf=/aai/v13/network/pnfs/pnf/{pnf-name}/p-interfaces/p-interface/{p-interface.interface-name}/l-interfaces/l-interface/{interface-name}
 
 # subinterface
-org.onap.ccsdk.sli.adaptors.aai.path.pnf.lag.interface.subinterface=/aai/v11/network/pnfs/pnf/{pnf-name}/lag-interfaces/lag-interface/{lag-interface.interface-name}/l-interfaces/l-interface/{interface-name}
-org.onap.ccsdk.sli.adaptors.aai.path.pnf.p.interface.l.interface=/aai/v11/network/pnfs/pnf/{pnf-name}/p-interfaces/p-interface/{p-interface.interface-name}/l-interfaces/l-interface/{interface-name}
+org.onap.ccsdk.sli.adaptors.aai.path.pnf.lag.interface.subinterface=/aai/v13/network/pnfs/pnf/{pnf-name}/lag-interfaces/lag-interface/{lag-interface.interface-name}/l-interfaces/l-interface/{interface-name}
+org.onap.ccsdk.sli.adaptors.aai.path.pnf.p.interface.l.interface=/aai/v13/network/pnfs/pnf/{pnf-name}/p-interfaces/p-interface/{p-interface.interface-name}/l-interfaces/l-interface/{interface-name}
 
 # vlans
-org.onap.ccsdk.sli.adaptors.aai.path.vlan=/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/tenants/tenant/{tenant-id}/vservers/vserver/{vserver-id}/l-interfaces/l-interface/{interface-name}/vlans/vlan/{vlan-interface}
-org.onap.ccsdk.sli.adaptors.aai.path.generic.vnf.vlan=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/vlans/vlan/{vlan-interface}
+org.onap.ccsdk.sli.adaptors.aai.path.vlan=/aai/v13/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/tenants/tenant/{tenant-id}/vservers/vserver/{vserver-id}/l-interfaces/l-interface/{interface-name}/vlans/vlan/{vlan-interface}
+org.onap.ccsdk.sli.adaptors.aai.path.generic.vnf.vlan=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/vlans/vlan/{vlan-interface}
 
 #  l3-interface-ipv4-address-list
-org.onap.ccsdk.sli.adaptors.aai.path.l3.interface.ipv4.address.list=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/l3-interface-ipv4-address-list/{l3-interface-ipv4-address}
-org.onap.ccsdk.sli.adaptors.aai.path.vlan.l3.interface.ipv4.address.list=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/vlans/vlan/{vlan-interface}/l3-interface-ipv4-address-list/{l3-interface-ipv4-address}
+org.onap.ccsdk.sli.adaptors.aai.path.l3.interface.ipv4.address.list=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/l3-interface-ipv4-address-list/{l3-interface-ipv4-address}
+org.onap.ccsdk.sli.adaptors.aai.path.vlan.l3.interface.ipv4.address.list=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/vlans/vlan/{vlan-interface}/l3-interface-ipv4-address-list/{l3-interface-ipv4-address}
 
 #  l3-interface-ipv6-address-list
-org.onap.ccsdk.sli.adaptors.aai.path.l3.interface.ipv6.address.list=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/l3-interface-ipv6-address-list/{l3-interface-ipv6-address}
-org.onap.ccsdk.sli.adaptors.aai.path.vlan.l3.interface.ipv6.address.list=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/vlans/vlan/{vlan-interface}/l3-interface-ipv6-address-list/{l3-interface-ipv6-address}
+org.onap.ccsdk.sli.adaptors.aai.path.l3.interface.ipv6.address.list=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/l3-interface-ipv6-address-list/{l3-interface-ipv6-address}
+org.onap.ccsdk.sli.adaptors.aai.path.vlan.l3.interface.ipv6.address.list=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/vlans/vlan/{vlan-interface}/l3-interface-ipv6-address-list/{l3-interface-ipv6-address}
 
 # ipsec-configuration
-org.onap.ccsdk.sli.adaptors.aai.path.ipsec.configuration=/aai/v11/network/ipsec-configurations/ipsec-configuration/{ipsec-configuration-id}
+org.onap.ccsdk.sli.adaptors.aai.path.ipsec.configuration=/aai/v13/network/ipsec-configurations/ipsec-configuration/{ipsec-configuration-id}
 
 # vig server
-org.onap.ccsdk.sli.adaptors.aai.path.vig.server=/aai/v11/network/ipsec-configurations/ipsec-configuration/{ipsec-configuration-id}/vig-servers/vig-server/{vig-address-type}
+org.onap.ccsdk.sli.adaptors.aai.path.vig.server=/aai/v13/network/ipsec-configurations/ipsec-configuration/{ipsec-configuration-id}/vig-servers/vig-server/{vig-address-type}
 
 # l3-network
-org.onap.ccsdk.sli.adaptors.aai.path.l3.network=/aai/v11/network/l3-networks/l3-network/{network-id}
+org.onap.ccsdk.sli.adaptors.aai.path.l3.network=/aai/v13/network/l3-networks/l3-network/{network-id}
 
 # subnet
-org.onap.ccsdk.sli.adaptors.aai.path.subnet=/aai/v11/network/l3-networks/l3-network/{network-id}/subnets/subnet/{subnet-id}
+org.onap.ccsdk.sli.adaptors.aai.path.subnet=/aai/v13/network/l3-networks/l3-network/{network-id}/subnets/subnet/{subnet-id}
 
 # multicast-configuration
-org.onap.ccsdk.sli.adaptors.aai.path.multicast.configuration=/aai/v11/network/multicast-configurations/multicast-configuration/{multicast-configuration-id}
+org.onap.ccsdk.sli.adaptors.aai.path.multicast.configuration=/aai/v13/network/multicast-configurations/multicast-configuration/{multicast-configuration-id}
 
 # org.onap.ccsdk.sli.adaptors.aai.path.l.interface.ipv4.address.list
-org.onap.ccsdk.sli.adaptors.aai.path.l3-interface.ipv4.address.list=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/l3-interface-ipv4-address-list/{l3-interface-ipv4-address}
+org.onap.ccsdk.sli.adaptors.aai.path.l3-interface.ipv4.address.list=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/l3-interface-ipv4-address-list/{l3-interface-ipv4-address}
 
 # org.onap.ccsdk.sli.adaptors.aai.path.l.interface.vlan.ipv4.address.list
-org.onap.ccsdk.sli.adaptors.aai.path.l3-interface.vlan.ipv4.address.list=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/vlans/vlan/{vlan-interface}/l3-interface-ipv4-address-list/{l3-interface-ipv4-address}
+org.onap.ccsdk.sli.adaptors.aai.path.l3-interface.vlan.ipv4.address.list=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/vlans/vlan/{vlan-interface}/l3-interface-ipv4-address-list/{l3-interface-ipv4-address}
 
 # org.onap.ccsdk.sli.adaptors.aai.path.l.interface.ipv6.address.list
-org.onap.ccsdk.sli.adaptors.aai.path.l3-interface.ipv6.address.list=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/l3-interface-ipv6-address-list/{l3-interface-ipv6-address}
+org.onap.ccsdk.sli.adaptors.aai.path.l3-interface.ipv6.address.list=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}/l3-interface-ipv6-address-list/{l3-interface-ipv6-address}
 
 # volume.group
-org.onap.ccsdk.sli.adaptors.aai.path.volume.group=/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/volume-groups/volume-group/{volume-group-id}
+org.onap.ccsdk.sli.adaptors.aai.path.volume.group=/aai/v13/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}/volume-groups/volume-group/{volume-group-id}
 
 #cloud region
-org.onap.ccsdk.sli.adaptors.aai.path.cloud.region=/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}
+org.onap.ccsdk.sli.adaptors.aai.path.cloud.region=/aai/v13/cloud-infrastructure/cloud-regions/cloud-region/{cloud-owner}/{cloud-region-id}
 
 # vf-module
-org.onap.ccsdk.sli.adaptors.aai.path.vf.module=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}/vf-modules/vf-module/{vf-module-id}
+org.onap.ccsdk.sli.adaptors.aai.path.vf.module=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}/vf-modules/vf-module/{vf-module-id}
 
 # l-interface through generic-vnf
-org.onap.ccsdk.sli.adaptors.aai.path.generic.vnf.linterface=/aai/v11/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}
+org.onap.ccsdk.sli.adaptors.aai.path.generic.vnf.linterface=/aai/v13/network/generic-vnfs/generic-vnf/{vnf-id}/l-interfaces/l-interface/{interface-name}
 
 # network-policy
-org.onap.ccsdk.sli.adaptors.aai.path.network.policy=/aai/v11/network/network-policies/network-policy/{network-policy-id}
+org.onap.ccsdk.sli.adaptors.aai.path.network.policy=/aai/v13/network/network-policies/network-policy/{network-policy-id}
 
 # pnf
-org.onap.ccsdk.sli.adaptors.aai.path.pnf=/aai/v11/network/pnfs/pnf/{pnf-name}
+org.onap.ccsdk.sli.adaptors.aai.path.pnf=/aai/v13/network/pnfs/pnf/{pnf-name}
 
 #
 # Formatting
diff --git a/kubernetes/sdnc/templates/statefulset.yaml b/kubernetes/sdnc/templates/statefulset.yaml
index ccf283f..c8565f5 100644
--- a/kubernetes/sdnc/templates/statefulset.yaml
+++ b/kubernetes/sdnc/templates/statefulset.yaml
@@ -49,7 +49,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           command: ["/bin/bash"]
           args: ["-c", "/opt/sdnc/bin/startODL.sh"]
@@ -202,4 +202,4 @@
       resources:
         requests:
           storage: {{ .Values.persistence.size }}
-  {{ end }}
\ No newline at end of file
+  {{ end }}
diff --git a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/01-load-default-sql-files.sh b/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/01-load-default-sql-files.sh
deleted file mode 100644
index 326f273..0000000
--- a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/01-load-default-sql-files.sh
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/sh
-#
-# ============LICENSE_START==========================================
-# ===================================================================
-# Copyright © 2017 AT&T Intellectual Property. All rights reserved.
-# ===================================================================
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============LICENSE_END============================================
-#
-# ECOMP and OpenECOMP are trademarks
-# and service marks of AT&T Intellectual Property.
-#
-#
-cd /docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-vfw
-mysql -uroot -p$MYSQL_ROOT_PASSWORD -f < create_mso_db-demo-vfw.sql
\ No newline at end of file
diff --git a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/02-load-additional-changes.sh b/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/02-load-additional-changes.sh
deleted file mode 100644
index a163801..0000000
--- a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/02-load-additional-changes.sh
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/bin/sh
-#
-# ============LICENSE_START==========================================
-# ===================================================================
-# Copyright © 2017 AT&T Intellectual Property. All rights reserved.
-# ===================================================================
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============LICENSE_END============================================
-#
-# ECOMP and OpenECOMP are trademarks
-# and service marks of AT&T Intellectual Property.
-#
-#
-
-# TODO: update this script to work with the new DB schema
-
-# mysql -uroot -p$MYSQL_ROOT_PASSWORD -e "UPDATE heat_environment SET ENVIRONMENT='parameters:\n  vfw_image_name: Ubuntu 14.04 LTS (Trusty Tahr) (PVHVM)\n  vfw_flavor_name: 4 GB General Purpose v1\n  public_net_id: 00000000-0000-0000-0000-000000000000\n  unprotected_private_net_id: zdfw1fwl01_unprotected\n  protected_private_net_id: zdfw1fwl01_protected\n  ecomp_private_net_id: oam_ecomp\n  unprotected_private_net_cidr: 192.168.10.0/24\n  protected_private_net_cidr: 192.168.20.0/24\n  ecomp_private_net_cidr: 192.168.9.0/24\n  vfw_private_ip_0: 192.168.10.100\n  vfw_private_ip_1: 192.168.20.100\n  vfw_private_ip_2: 192.168.9.100\n  vpg_private_ip_0: 192.168.10.200\n  vpg_private_ip_1: 192.168.9.200\n  vsn_private_ip_0: 192.168.20.250\n  vsn_private_ip_1: 192.168.9.250\n  vfw_name_0: zdfw1fwl01fwl01\n  vpg_name_0: zdfw1fwl01pgn01\n  vsn_name_0: zdfw1fwl01snk01\n  vnf_id: vFirewall_demo_app\n  vf_module_id: vFirewall\n  webserver_ip: 162.242.237.182\n  dcae_collector_ip: 192.168.9.1\n  key_name: vfw_key\n  pub_key: INSERT YOUR PUBLIC KEY HERE' where id=5;" mso_catalog
diff --git a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/automated-tests/create_mso_db-tests.sql b/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/automated-tests/create_mso_db-tests.sql
deleted file mode 100644
index 0b3dde5..0000000
--- a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/automated-tests/create_mso_db-tests.sql
+++ /dev/null
@@ -1,64 +0,0 @@
-/* Copyright © 2017 AT&T, Amdocs, Bell Canada
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*       http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-SOURCE ../default/create_mso_db-default.sql
-
-USE `mso_requests`;
-DROP USER 'mso';
-CREATE USER 'mso';
-GRANT ALL on mso_requests.* to 'mso' identified by 'mso123' with GRANT OPTION;
-FLUSH PRIVILEGES;
-
-USE `mso_catalog`;
-DROP USER 'catalog';
-CREATE USER 'catalog';
-GRANT ALL on mso_catalog.* to 'catalog' identified by 'catalog123' with GRANT OPTION;
-FLUSH PRIVILEGES;
-
-LOCK TABLES `NETWORK_RESOURCE` WRITE;
-/*!40000 ALTER TABLE `NETWORK_RESOURCE` DISABLE KEYS */;
-/*!40000 ALTER TABLE `NETWORK_RESOURCE` ENABLE KEYS */;
-insert into NETWORK_RESOURCE (id, NETWORK_TYPE, VERSION_STR, ORCHESTRATION_MODE ,DESCRIPTION, TEMPLATE_ID, NEUTRON_NETWORK_TYPE, AIC_VERSION_MIN) values
-(1, "vlan",'1',"NEUTRON","Cool network",1,"BASIC","0");
-UNLOCK TABLES;
-
-LOCK TABLES `NETWORK_RECIPE` WRITE;
-/*!40000 ALTER TABLE `NETWORK_RECIPE` DISABLE KEYS */;
-INSERT INTO `NETWORK_RECIPE`(`NETWORK_TYPE`, `ACTION`, `VERSION_STR`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`) VALUES
-('vlan','CREATE','1',NULL,'/active-bpel/services/REST/CreateNetwork',NULL,180,NULL),
-('vlan','DELETE','1',NULL,'/active-bpel/services/REST/DeleteNetwork',NULL,180,NULL);
-/*!40000 ALTER TABLE `NETWORK_RECIPE` ENABLE KEYS */;
-UNLOCK TABLES;
-
-LOCK TABLES `VNF_RECIPE` WRITE;
-INSERT INTO `VNF_RECIPE`(`ID`, `VNF_TYPE`, `ACTION`, `VERSION_STR`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`) VALUES
-(100,'VPE','CREATE','1','','/active-bpel/services/REST/CreateGenericVNF','',180,'SDN-ETHERNET-INTERNET'),
-(101,'VPE','DELETE','1','','/active-bpel/services/REST/DeleteGenericVNF','',180,'SDN-ETHERNET-INTERNET');
-UNLOCK TABLES;
-
-LOCK TABLES `VF_MODULE` WRITE;
-INSERT INTO `VF_MODULE`(`ID`, `TYPE`, `ASDC_SERVICE_MODEL_VERSION`, `MODEL_NAME`, `MODEL_VERSION`, `IS_BASE`, `VNF_RESOURCE_ID`) VALUES
-(100,'dns-servicetest/DNSResource-1::VF_DNS::module-1','1.0','VF_DNS::module-1','1.0','1','7'),
-(101,'dns-servicetest/DNSResource-1::Mog111..mog_psm..module-1','1.0','Mog111..mog_psm..module-1','1.0','1','7');
-UNLOCK TABLES;
-
-LOCK TABLES `VNF_RESOURCE` WRITE;
-INSERT INTO `VNF_RESOURCE`(`ID`, `VNF_TYPE`, `ASDC_SERVICE_MODEL_VERSION`, `ORCHESTRATION_MODE`, `MODEL_VERSION`) VALUES
-(100,'dns-servicetest/DNSResource-1','1.0','VF_DNS::module-1','1.0');
-UNLOCK TABLES;
-
-DELETE FROM HEAT_TEMPLATE_PARAMS;
-DELETE FROM HEAT_TEMPLATE;
-DELETE FROM HEAT_ENVIRONMENT;
diff --git a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/default/create_mso_db-default.sql b/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/default/create_mso_db-default.sql
deleted file mode 100644
index ad303db..0000000
--- a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/default/create_mso_db-default.sql
+++ /dev/null
@@ -1,154 +0,0 @@
-/* Copyright © 2017 AT&T, Amdocs, Bell Canada
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*       http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-SOURCE ../../camunda/mariadb_engine_7.7.3-ee.sql
-
---
--- Create an admin user automatically for the cockpit
---
-SOURCE ../../camunda/mysql_create_camunda_admin.sql
-
---
--- Current Database: `mso_requests`
---
-
-DROP DATABASE IF EXISTS `mso_requests`;
-
-CREATE DATABASE /*!32312 IF NOT EXISTS*/ `mso_requests` /*!40100 DEFAULT CHARACTER SET latin1 */;
-
-USE `mso_requests`;
-
-SOURCE ../../main-schemas/MySQL-Requests-schema.sql
-
---
--- Current Database: `mso_catalog`
---
-
-DROP DATABASE IF EXISTS `mso_catalog`;
-
-CREATE DATABASE /*!32312 IF NOT EXISTS*/ `mso_catalog` /*!40100 DEFAULT CHARACTER SET latin1 */;
-
-USE `mso_catalog`;
-
-SOURCE ../../main-schemas/MySQL-Catalog-schema.sql
-
-SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
-
-INSERT INTO `heat_template` (`ARTIFACT_UUID`, `NAME`, `VERSION`, `DESCRIPTION`, `BODY`, `TIMEOUT_MINUTES`, `ARTIFACT_CHECKSUM`, `CREATION_TIMESTAMP`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','Contrail30-l2nodhcp','1',NULL,'heat_template_version: 2015-04-30\n\ndescription:\n  HOT template that creates a Contrail Virtual Network with L2NODHCP\n\nparameters:\n  network_name:\n     type: string\n     description: Name of direct network (e.g. core, dmz)\n     default: ECOMPNetwork\n  shared:\n     type: boolean\n     description: Shared amongst tenants\n     default: False\n  external:\n     type: boolean\n     description: router_external for the VirtualNetwork\n     default: False\n  route_targets:\n    type: comma_delimited_list\n    description: Network route-targets (RT)\n    default: \"\"\n  subnet_list:\n     type: json\n     description: Network subnets\n     default: []\n  policy_refs:\n     type: comma_delimited_list\n     description: Policies referenced by Network\n     default: \"\"\n  policy_refsdata:\n     type: json\n     description: Policies referenced by Network\n     default: []\n  route_table_refs:\n     type: comma_delimited_list\n     description: Route Tables referenced by Network\n     default: \"\"\n  virtual_network_properties_allow_transit:\n     type: boolean\n     description: allow_transit for the VirtualNetwork\n     default: True\n  virtual_network_properties_forwarding_mode:\n     type: string\n     description: forwarding_mode for the VirtualNetwork\n     default: l2\n  virtual_network_properties_rpf:\n     type: string\n     description: rpf for the VirtualNetwork\n     default: disable\n  flood_unknown_unicast:\n     type: boolean\n     description: flood_unknown_unicast for the VirtualNetwork\n     default: True\n\noutputs:\n  network_id:\n    description: Openstack network identifier\n    value: { get_resource: network }\n  network_fqdn:\n    description: Openstack network identifier\n    value: {list_join: [\':\', { get_attr: [network, fq_name] } ] }\n\nresources:\n  networkIpam:\n    type: OS::ContrailV2::NetworkIpam\n    properties:\n      name: { get_param: network_name }\n\n  network:\n    type: OS::ContrailV2::VirtualNetwork\n    properties:\n      name: { get_param: network_name }\n      is_shared: {get_param: shared}\n      router_external: { get_param: external }\n      route_target_list:\n        {\n           route_target_list_route_target: { get_param: route_targets }\n        }\n      network_ipam_refs: [{ get_resource: networkIpam }]\n      network_ipam_refs_data:\n        [\n          {\n             network_ipam_refs_data_ipam_subnets: { get_param: subnet_list }\n          }\n        ]\n      network_policy_refs:  { get_param: policy_refs }\n      network_policy_refs_data: { get_param: policy_refsdata }\n      route_table_refs: { get_param: route_table_refs }\n      flood_unknown_unicast: { get_param: flood_unknown_unicast }  \n      virtual_network_properties:\n        {\n           virtual_network_properties_allow_transit: { get_param: virtual_network_properties_allow_transit },\n           virtual_network_properties_forwarding_mode: { get_param: virtual_network_properties_forwarding_mode },\n           virtual_network_properties_rpf: { get_param: virtual_network_properties_rpf },\n        }\n',10,'MANUAL RECORD','2017-10-05 18:52:03');
-
-INSERT INTO `heat_template` (`ARTIFACT_UUID`, `NAME`, `VERSION`, `DESCRIPTION`, `BODY`, `TIMEOUT_MINUTES`, `ARTIFACT_CHECKSUM`, `CREATION_TIMESTAMP`) VALUES ('4885c7a1-a9fe-11e7-8b4b-0242ac120002','Contrail30-gndirect','1',NULL,'heat_template_version: 2015-04-30\n\ndescription:\n  HOT template that creates a Contrail Virtual Network for GNDIRECT\n\nparameters:\n  network_name:\n     type: string\n     description: Name of direct network (e.g. core, dmz)\n     default: ECOMPNetwork\n  shared:\n     type: boolean\n     description: Shared amongst tenants\n     default: False\n  external:\n     type: boolean\n     description: router_external for the VirtualNetwork\n     default: False\n  route_targets:\n    type: comma_delimited_list\n    description: Network route-targets (RT)\n    default: \"\"\n  subnet_list:\n     type: json\n     description: Network subnets\n     default: []\n  policy_refs:\n     type: comma_delimited_list\n     description: Policies referenced by Network\n     default: \"\"\n  policy_refsdata:\n     type: json\n     description: Policies referenced by Network\n     default: []\n  route_table_refs:\n     type: comma_delimited_list\n     description: Route Tables referenced by Network\n     default: \"\"\n  virtual_network_properties_rpf:\n     type: string\n     description: rpf for the VirtualNetwork\n     default: disable\n\noutputs:\n  network_id:\n    description: Openstack network identifier\n    value: { get_resource: network }\n  network_fqdn:\n    description: Openstack network identifier\n    value: {list_join: [\':\', { get_attr: [network, fq_name] } ] }\n\nresources:\n  networkIpam:\n    type: OS::ContrailV2::NetworkIpam\n    properties:\n      name: { get_param: network_name }\n\n  network:\n    type: OS::ContrailV2::VirtualNetwork\n    properties:\n      name: { get_param: network_name }\n      is_shared: {get_param: shared}\n      router_external: { get_param: external }\n      route_target_list:\n        {\n           route_target_list_route_target: { get_param: route_targets }\n        }\n      network_ipam_refs: [{ get_resource: networkIpam }]\n      network_ipam_refs_data:\n        [\n          {\n             network_ipam_refs_data_ipam_subnets: { get_param: subnet_list }\n          }\n        ]\n      network_policy_refs:  { get_param: policy_refs }\n      network_policy_refs_data: { get_param: policy_refsdata }\n      route_table_refs: { get_param: route_table_refs }\n      virtual_network_properties:\n        {\n           virtual_network_properties_rpf: { get_param: virtual_network_properties_rpf }\n        }\n',10,'MANUAL RECORD','2017-10-05 18:52:03');
-
-INSERT INTO `heat_template` (`ARTIFACT_UUID`,`NAME`,`VERSION`,`BODY`,`TIMEOUT_MINUTES`,`DESCRIPTION`,`CREATION_TIMESTAMP`,`ARTIFACT_CHECKSUM`) VALUES ('efee1d84-b8ec-11e7-abc4-cec278b6b50a','Generic NeutronNet','1','heat_template_version: 2013-05-23\n\ndescription:\n  HOT template that creates a Generic Neutron Network\n\nparameters:\n  network_name:\n     type: string\n     description: Name of direct network (e.g. core, dmz)\n     default: ECOMPNetwork\n  network_subnet_name:\n     type: string\n     description: Name of subnet network (e.g. core, dmz)\n     default: ECOMPNetwork\n  network_subnet_cidr:\n     type: string\n     description: CIDR of subnet network (e.g. core, dmz)\n     default: 10.0.0.0/16\n\noutputs:\n  network_id:\n    description: Openstack network identifier\n    value: { get_resource: network }\n  network_fqdn:\n    description: Openstack network identifier\n    value: {list_join: [\':\', { get_attr: [network, fq_name] } ] }\n\nresources:\n              network:\n                type: OS::Neutron::Net\n                properties:\n                name: {get_param: network_name }\n\n              subnet:\n                type: OS::Neutron::Subnet\n                properties:\n                name: { get_param: network_subnet_name  }\n                network_id: { get_resource: network }\n                cidr: { get_param: network_subnet_cidr }\n                enable_dhcp: false\n',10,'Generic Neutron Template','2017-10-26 14:44:00', 'MANUAL RECORD');
-
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','external','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','flood_unknown_unicast','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','network_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','policy_refs','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','policy_refsdata','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','route_table_refs','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','route_targets','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','shared','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','virtual_network_properties_allow_transit','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','virtual_network_properties_forwarding_mode','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c198-a9fe-11e7-8b4b-0242ac120002','virtual_network_properties_rpf','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c7a1-a9fe-11e7-8b4b-0242ac120002','external','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c7a1-a9fe-11e7-8b4b-0242ac120002','network_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c7a1-a9fe-11e7-8b4b-0242ac120002','policy_refs','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c7a1-a9fe-11e7-8b4b-0242ac120002','policy_refsdata','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c7a1-a9fe-11e7-8b4b-0242ac120002','route_table_refs','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c7a1-a9fe-11e7-8b4b-0242ac120002','route_targets','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c7a1-a9fe-11e7-8b4b-0242ac120002','shared','\0','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('4885c7a1-a9fe-11e7-8b4b-0242ac120002','virtual_network_properties_rpf','\0','string',NULL);
-
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (1,'CONTRAIL_BASIC','CREATE',NULL,'/mso/async/services/CreateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (2,'CONTRAIL_BASIC','DELETE',NULL,'/mso/async/services/DeleteNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (3,'CONTRAIL_BASIC','UPDATE',NULL,'/mso/async/services/UpdateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (4,'CONTRAIL_SHARED','CREATE',NULL,'/mso/async/services/CreateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (5,'CONTRAIL_SHARED','UPDATE',NULL,'/mso/async/services/UpdateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (6,'CONTRAIL_SHARED','DELETE',NULL,'/mso/async/services/DeleteNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (7,'CONTRAIL_EXTERNAL','CREATE',NULL,'/mso/async/services/CreateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (8,'CONTRAIL_EXTERNAL','UPDATE',NULL,'/mso/async/services/UpdateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (9,'CONTRAIL_EXTERNAL','DELETE',NULL,'/mso/async/services/DeleteNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (10,'CONTRAIL30_BASIC','CREATE',NULL,'/mso/async/services/CreateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (11,'CONTRAIL30_BASIC','UPDATE',NULL,'/mso/async/services/UpdateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (12,'CONTRAIL30_BASIC','DELETE',NULL,'/mso/async/services/DeleteNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (13,'CONTRAIL30_MPSCE','CREATE',NULL,'/mso/async/services/CreateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (14,'CONTRAIL30_MPSCE','UPDATE',NULL,'/mso/async/services/UpdateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (15,'CONTRAIL30_MPSCE','DELETE',NULL,'/mso/async/services/DeleteNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (16,'VID_DEFAULT','createInstance','VID_DEFAULT recipe to create network if no custom BPMN flow is found','/mso/async/services/CreateNetworkInstance',NULL,180,NULL,'2017-10-05 18:52:03','1.0');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (17,'VID_DEFAULT','updateInstance','VID_DEFAULT recipe to update network if no custom BPMN flow is found','/mso/async/services/UpdateNetworkInstance',NULL,180,NULL,'2017-10-05 18:52:03','1.0');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (18,'VID_DEFAULT','deleteInstance','VID_DEFAULT recipe to delete network if no custom BPMN flow is found','/mso/async/services/DeleteNetworkInstance',NULL,180,NULL,'2017-10-05 18:52:03','1.0');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (19,'CONTRAIL30_L2NODHCP','CREATE',NULL,'/mso/async/services/CreateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (20,'CONTRAIL30_L2NODHCP','UPDATE',NULL,'/mso/async/services/UpdateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (21,'CONTRAIL30_L2NODHCP','DELETE',NULL,'/mso/async/services/DeleteNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (22,'CONTRAIL30_GNDIRECT','CREATE',NULL,'/mso/async/services/CreateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (23,'CONTRAIL30_GNDIRECT','UPDATE',NULL,'/mso/async/services/UpdateNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-INSERT INTO `network_recipe` (`id`, `MODEL_NAME`, `ACTION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `NETWORK_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`, `CREATION_TIMESTAMP`, `VERSION_STR`) VALUES (24,'CONTRAIL30_GNDIRECT','DELETE',NULL,'/mso/async/services/DeleteNetworkV2',NULL,180,NULL,'2017-10-05 18:52:03','1');
-
-INSERT INTO `service` (`MODEL_UUID`, `MODEL_NAME`, `MODEL_INVARIANT_UUID`, `MODEL_VERSION`, `DESCRIPTION`, `CREATION_TIMESTAMP`, `TOSCA_CSAR_ARTIFACT_UUID`) VALUES ('48cc36cc-a9fe-11e7-8b4b-0242ac120002','VID_DEFAULT','48cd56c8-a9fe-11e7-8b4b-0242ac120002','1.0','Default service for VID to use for infra APIH orchestration1707MIGRATED1707MIGRATED','2017-10-05 18:52:03',NULL);
-INSERT INTO `service` (`MODEL_UUID`, `MODEL_NAME`, `MODEL_INVARIANT_UUID`, `MODEL_VERSION`, `DESCRIPTION`, `CREATION_TIMESTAMP`, `TOSCA_CSAR_ARTIFACT_UUID`) VALUES ('48cc3acd-a9fe-11e7-8b4b-0242ac120002','*','48ce2256-a9fe-11e7-8b4b-0242ac120002','1.0','Default service to use for infra APIH orchestration1707MIGRATED1707MIGRATED','2017-10-05 18:52:03',NULL);
-
-INSERT INTO `service_recipe` (`id`, `ACTION`, `VERSION_STR`, `DESCRIPTION`, `ORCHESTRATION_URI`, `SERVICE_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TIMEOUT_INTERIM`, `CREATION_TIMESTAMP`, `SERVICE_MODEL_UUID`) VALUES (1,'createInstance','1','VID_DEFAULT recipe to create service-instance if no custom BPMN flow is found','/mso/async/services/CreateGenericALaCarteServiceInstance',NULL,180,NULL,'2017-10-05 18:52:03','48cc36cc-a9fe-11e7-8b4b-0242ac120002');
-INSERT INTO `service_recipe` (`id`, `ACTION`, `VERSION_STR`, `DESCRIPTION`, `ORCHESTRATION_URI`, `SERVICE_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TIMEOUT_INTERIM`, `CREATION_TIMESTAMP`, `SERVICE_MODEL_UUID`) VALUES (2,'deleteInstance','1','VID_DEFAULT recipe to delete service-instance if no custom BPMN flow is found','/mso/async/services/DeleteGenericALaCarteServiceInstance',NULL,180,NULL,'2017-10-05 18:52:03','48cc36cc-a9fe-11e7-8b4b-0242ac120002');
-INSERT INTO `service_recipe` (`id`, `ACTION`, `VERSION_STR`, `DESCRIPTION`, `ORCHESTRATION_URI`, `SERVICE_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TIMEOUT_INTERIM`, `CREATION_TIMESTAMP`, `SERVICE_MODEL_UUID`) VALUES (3,'createInstance','1','DEFAULT recipe to create service-instance if no custom BPMN flow is found','/mso/async/services/CreateGenericALaCarteServiceInstance',NULL,180,NULL,'2017-10-05 18:52:03','48cc3acd-a9fe-11e7-8b4b-0242ac120002');
-INSERT INTO `service_recipe` (`id`, `ACTION`, `VERSION_STR`, `DESCRIPTION`, `ORCHESTRATION_URI`, `SERVICE_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TIMEOUT_INTERIM`, `CREATION_TIMESTAMP`, `SERVICE_MODEL_UUID`) VALUES (4,'deleteInstance','1','DEFAULT recipe to delete service-instance if no custom BPMN flow is found','/mso/async/services/DeleteGenericALaCarteServiceInstance',NULL,180,NULL,'2017-10-05 18:52:03','48cc3acd-a9fe-11e7-8b4b-0242ac120002');
-
---
--- Custom Reciepe for the VoLTE service added temporarily
---
-
-INSERT INTO `service` (`MODEL_UUID`, `MODEL_NAME`, `MODEL_INVARIANT_UUID`, `MODEL_VERSION`, `DESCRIPTION`, `CREATION_TIMESTAMP`, `TOSCA_CSAR_ARTIFACT_UUID`) VALUES ('dfcd7471-16c7-444e-8268-d4c50d90593a','UUI_DEFAULT','dfcd7471-16c7-444e-8268-d4c50d90593a','1.0','Default service for UUI to use for infra APIH orchestration1707MIGRATED1707MIGRATED','2017-10-23 18:52:03',NULL);
-
-INSERT INTO `service_recipe` (`id`, `ACTION`, `VERSION_STR`, `DESCRIPTION`, `ORCHESTRATION_URI`, `SERVICE_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TIMEOUT_INTERIM`, `CREATION_TIMESTAMP`, `SERVICE_MODEL_UUID`) VALUES (11,'createInstance','1','Custom recipe to create E2E service-instance if no custom BPMN flow is found','/mso/async/services/CreateCustomE2EServiceInstance',NULL,180,NULL,'2017-10-05 18:52:03','dfcd7471-16c7-444e-8268-d4c50d90593a');
-INSERT INTO `service_recipe` (`id`, `ACTION`, `VERSION_STR`, `DESCRIPTION`, `ORCHESTRATION_URI`, `SERVICE_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TIMEOUT_INTERIM`, `CREATION_TIMESTAMP`, `SERVICE_MODEL_UUID`) VALUES (12,'deleteInstance','1','Custom recipe to delete E2E service-instance if no custom BPMN flow is found','/mso/async/services/DeleteCustomE2EServiceInstance',NULL,180,NULL,'2017-10-05 18:52:03','dfcd7471-16c7-444e-8268-d4c50d90593a');
-
-INSERT INTO `temp_network_heat_template_lookup` (`NETWORK_RESOURCE_MODEL_NAME`, `HEAT_TEMPLATE_ARTIFACT_UUID`, `AIC_VERSION_MIN`, `AIC_VERSION_MAX`) VALUES ('CONTRAIL30_GNDIRECT','4885c7a1-a9fe-11e7-8b4b-0242ac120002','3.0',NULL);
-INSERT INTO `temp_network_heat_template_lookup` (`NETWORK_RESOURCE_MODEL_NAME`, `HEAT_TEMPLATE_ARTIFACT_UUID`, `AIC_VERSION_MIN`, `AIC_VERSION_MAX`) VALUES ('CONTRAIL30_L2NODHCP','4885c198-a9fe-11e7-8b4b-0242ac120002','3.0',NULL);
-INSERT INTO `temp_network_heat_template_lookup` (`NETWORK_RESOURCE_MODEL_NAME`, `HEAT_TEMPLATE_ARTIFACT_UUID`,`AIC_VERSION_MIN` , `AIC_VERSION_MAX` ) VALUES ('Generic NeutronNet','efee1d84-b8ec-11e7-abc4-cec278b6b50a','2.0','NULL');
-
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (1,'*','VOLUME_GROUP',NULL,'CREATE',NULL,'1','Recipe Match All for','/mso/async/services/createCinderVolumeV1',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (2,'*','VOLUME_GROUP',NULL,'DELETE',NULL,'1','Recipe Match All for','/mso/async/services/deleteCinderVolumeV1',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (3,'*','VOLUME_GROUP',NULL,'UPDATE',NULL,'1','Recipe Match All for','/mso/async/services/updateCinderVolumeV1',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (4,NULL,'VOLUME_GROUP',NULL,'CREATE_VF_MODULE_VOL',NULL,'1','Recipe Match All for','/mso/async/services/CreateVfModuleVolume',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (5,NULL,'VOLUME_GROUP',NULL,'DELETE_VF_MODULE_VOL',NULL,'1','Recipe Match All for','/mso/async/services/DeleteVfModuleVolume',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (6,NULL,'VOLUME_GROUP',NULL,'UPDATE_VF_MODULE_VOL',NULL,'1','Recipe Match All for','/mso/async/services/UpdateVfModuleVolume',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (7,NULL,'volumeGroup','VID_DEFAULT','createInstance',NULL,'1','VID_DEFAULT recipe t','/mso/async/services/CreateVfModuleVolumeInfraV1',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (8,NULL,'volumeGroup','VID_DEFAULT','deleteInstance',NULL,'1','VID_DEFAULT recipe t','/mso/async/services/DeleteVfModuleVolumeInfraV1',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (9,NULL,'volumeGroup','VID_DEFAULT','updateInstance',NULL,'1','VID_DEFAULT recipe t','/mso/async/services/UpdateVfModuleVolumeInfraV1',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (10,NULL,'vfModule','VID_DEFAULT','createInstance',NULL,'1','VID_DEFAULT recipe t','/mso/async/services/CreateVfModuleInfra',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (11,NULL,'vfModule','VID_DEFAULT','deleteInstance',NULL,'1','VID_DEFAULT recipe t','/mso/async/services/DeleteVfModuleInfra',null,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_components_recipe` (`id`, `VNF_TYPE`, `VNF_COMPONENT_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `SERVICE_TYPE`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (12,NULL,'vfModule','VID_DEFAULT','updateInstance',NULL,'1','VID_DEFAULT recipe t','/mso/async/services/UpdateVfModuleInfra',null,180,'2017-10-05 18:52:03');
-
---
--- Default Reciepe for the VNF componnets added start #SO-334, to unblock the VNF operations
---
-
-INSERT INTO `vnf_components_recipe` (`VNF_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`,`VNF_COMPONENT_TYPE`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`) VALUES  (NULL,'POLICY_DEFAULT','createInstance','1','Recipe Match POLICY_DEFAULT for VF Modules if no custom flow exists','/mso/async/services/CreateVfModuleInfra','vfModule',NULL,180,NULL);
-INSERT INTO `vnf_components_recipe` (`VNF_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`,`VNF_COMPONENT_TYPE`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`) VALUES (NULL,'POLICY_DEFAULT','updateInstance','1','Recipe Match POLICY_DEFAULT for VF Modules if no custom flow exists','/mso/async/services/UpdateVfModuleInfra','vfModule',NULL,180,NULL);
-INSERT INTO `vnf_components_recipe` (`VNF_TYPE`, `VF_MODULE_MODEL_UUID`, `ACTION`, `VERSION`, `DESCRIPTION`, `ORCHESTRATION_URI`,`VNF_COMPONENT_TYPE`, `VNF_COMPONENT_PARAM_XSD`, `RECIPE_TIMEOUT`, `SERVICE_TYPE`) VALUES (NULL,'POLICY_DEFAULT','deleteInstance','1','Recipe Match POLICY_DEFAULT for VF Modules if no custom flow exists','/mso/async/services/DeleteVfModuleInfra','vfModule',NULL,180,NULL);
---
--- Default Reciepe for the VNF componnets added End
---
-
-INSERT INTO `vnf_recipe` (`id`, `VF_MODULE_ID`, `ACTION`, `SERVICE_TYPE`, `VERSION_STR`, `VNF_TYPE`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (1,NULL,'CREATE',NULL,'1','*','Recipe Match All for VNFs if no custom flow exists','/mso/workflow/services/CreateGenericVNFV1',NULL,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_recipe` (`id`, `VF_MODULE_ID`, `ACTION`, `SERVICE_TYPE`, `VERSION_STR`, `VNF_TYPE`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (2,NULL,'DELETE',NULL,'1','*','Recipe Match All for VNFs if no custom flow exists','/mso/async/services//deleteGenericVNFV1',NULL,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_recipe` (`id`, `VF_MODULE_ID`, `ACTION`, `SERVICE_TYPE`, `VERSION_STR`, `VNF_TYPE`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (3,NULL,'UPDATE',NULL,'1','*','Recipe Match All for VNFs if no custom flow exists','/mso/workflow/services/updateGenericVNFV1',NULL,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_recipe` (`id`, `VF_MODULE_ID`, `ACTION`, `SERVICE_TYPE`, `VERSION_STR`, `VNF_TYPE`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (4,'*','CREATE_VF_MODULE',NULL,'1',NULL,'Recipe Match All for VNFs if no custom flow exists','/mso/async/services/CreateVfModule',NULL,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_recipe` (`id`, `VF_MODULE_ID`, `ACTION`, `SERVICE_TYPE`, `VERSION_STR`, `VNF_TYPE`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (5,'*','DELETE_VF_MODULE',NULL,'1',NULL,'Recipe Match All for VNFs if no custom flow exists','/mso/async/services/DeleteVfModule',NULL,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_recipe` (`id`, `VF_MODULE_ID`, `ACTION`, `SERVICE_TYPE`, `VERSION_STR`, `VNF_TYPE`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (6,'*','UPDATE_VF_MODULE',NULL,'1',NULL,'Recipe Match All for VNFs if no custom flow exists','/mso/async/services/UpdateVfModule',NULL,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_recipe` (`id`, `VF_MODULE_ID`, `ACTION`, `SERVICE_TYPE`, `VERSION_STR`, `VNF_TYPE`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (7,NULL,'createInstance',NULL,'1','VID_DEFAULT','VID_DEFAULT recipe to create VNF if no custom BPMN flow is found','/mso/async/services/CreateVnfInfra',NULL,180,'2017-10-05 18:52:03');
-INSERT INTO `vnf_recipe` (`id`, `VF_MODULE_ID`, `ACTION`, `SERVICE_TYPE`, `VERSION_STR`, `VNF_TYPE`, `DESCRIPTION`, `ORCHESTRATION_URI`, `VNF_PARAM_XSD`, `RECIPE_TIMEOUT`, `CREATION_TIMESTAMP`) VALUES (8,NULL,'deleteInstance',NULL,'1','VID_DEFAULT','VID_DEFAULT recipe to delete VNF if no custom BPMN flow is found','/mso/async/services/DeleteVnfInfra',NULL,180,'2017-10-05 18:52:03');
-
-SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
diff --git a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-dns/create_mso_db-demo-dns.sql b/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-dns/create_mso_db-demo-dns.sql
deleted file mode 100644
index 2bb939b..0000000
--- a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-dns/create_mso_db-demo-dns.sql
+++ /dev/null
@@ -1,92 +0,0 @@
-/* Copyright © 2017 AT&T, Amdocs, Bell Canada
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*       http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-SOURCE ../default/create_mso_db-default.sql
-
-USE `mso_requests`;
-DROP USER 'mso';
-CREATE USER 'mso';
-GRANT ALL on mso_requests.* to 'mso' identified by 'mso123' with GRANT OPTION;
-FLUSH PRIVILEGES;
-
-USE `mso_catalog`;
-DROP USER 'catalog';
-CREATE USER 'catalog';
-GRANT ALL on mso_catalog.* to 'catalog' identified by 'catalog123' with GRANT OPTION;
-FLUSH PRIVILEGES;
-
-SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
-
-INSERT INTO `heat_environment` (`ARTIFACT_UUID`, `NAME`, `VERSION`, `DESCRIPTION`, `BODY`, `ARTIFACT_CHECKSUM`, `CREATION_TIMESTAMP`) VALUES ('EnvArtifact-UUID1','base_vlb.env','1.0','BASE VLB ENV file','parameters:\n  vlb_image_name: Ubuntu 14.04 LTS (Trusty Tahr) (PVHVM)\n  vlb_flavor_name: 4 GB General Purpose v1\n  public_net_id: 00000000-0000-0000-0000-000000000000\n  vlb_private_net_id: zdfw1lb01_private\n  ecomp_private_net_id: oam_ecomp\n  vlb_private_net_cidr: 192.168.10.0/24\n  ecomp_private_net_cidr: 192.168.9.0/24\n  vlb_private_ip_0: 192.168.10.111\n  vlb_private_ip_1: 192.168.9.111\n  vdns_private_ip_0: 192.168.10.211\n  vdns_private_ip_1: 192.168.9.211\n  vlb_name_0: zdfw1lb01lb01\n  vdns_name_0: zdfw1lb01dns01\n  vnf_id: vLoadBalancer_demo_app\n  vf_module_id: vLoadBalancer\n  webserver_ip: 162.242.237.182\n  dcae_collector_ip: 192.168.9.1\n  key_name: vlb_key\n  pub_key: INSERT YOUR PUBLIC KEY HERE','MANUAL RECORD','2016-11-14 13:04:07');
-
-INSERT INTO `heat_environment` (`ARTIFACT_UUID`, `NAME`, `VERSION`, `DESCRIPTION`, `BODY`, `ARTIFACT_CHECKSUM`, `CREATION_TIMESTAMP`) VALUES ('EnvArtifact-UUID2','dnsscaling.env','1.0','DNS Scaling ENV file','parameters:\n  vlb_image_name: Ubuntu 14.04 LTS (Trusty Tahr) (PVHVM)\n  vlb_flavor_name: 4 GB General Purpose v1\n  public_net_id: 00000000-0000-0000-0000-000000000000\n  vlb_private_net_id: zdfw1lb01_private\n  ecomp_private_net_id: oam_ecomp\n  vlb_private_ip_0: 192.168.10.111\n  vlb_private_ip_1: 192.168.9.111\n  vdns_private_ip_0: 192.168.10.222\n  vdns_private_ip_1: 192.168.9.222\n  vdns_name_0: zdfw1lb01dns02\n  vnf_id: vLoadBalancer_demo_app\n  vf_module_id: vLoadBalancer\n  webserver_ip: 162.242.237.182\n  dcae_collector_ip: 192.168.9.1\n  key_name: vlb_key\n  pub_key: INSERT YOUR PUBLIC KEY HERE','MANUAL RECORD','2016-11-14 13:04:07');
-
-INSERT INTO `heat_template` (`ARTIFACT_UUID`, `NAME`, `VERSION`, `DESCRIPTION`, `BODY`, `TIMEOUT_MINUTES`, `ARTIFACT_CHECKSUM`, `CREATION_TIMESTAMP`) VALUES ('Artifact-UUID1','base_vlb.yaml','1.0','Base VLB Heat','heat_template_version: 2013-05-23\n\ndescription: Heat template to deploy vLoadBalancer/vDNS demo app for OpenECOMP\n\nparameters:\n  vlb_image_name:\n    type: string\n    label: Image name or ID\n    description: Image to be used for compute instance\n  vlb_flavor_name:\n    type: string\n    label: Flavor\n    description: Type of instance (flavor) to be used\n  public_net_id:\n    type: string\n    label: Public network name or ID\n    description: Public network that enables remote connection to VNF\n  vlb_private_net_id:\n    type: string\n    label: vLoadBalancer private network name or ID\n    description: Private network that connects vLoadBalancer with vDNSs\n  ecomp_private_net_id:\n    type: string\n    label: ECOMP management network name or ID\n    description: Private network that connects ECOMP component and the VNF\n  vlb_private_net_cidr:\n    type: string\n    label: vLoadBalancer private network CIDR\n    description: The CIDR of the vLoadBalancer private network\n  ecomp_private_net_cidr:\n    type: string\n    label: ECOMP private network CIDR\n    description: The CIDR of the protected private network\n  vlb_private_ip_0:\n    type: string\n    label: vLoadBalancer private IP address towards the private network\n    description: Private IP address that is assigned to the vLoadBalancer to communicate with the vDNSs\n  vlb_private_ip_1:\n    type: string\n    label: vLoadBalancer private IP address towards the ECOMP management network\n    description: Private IP address that is assigned to the vLoadBalancer to communicate with ECOMP components\n  vdns_private_ip_0:\n    type: string\n    label: vDNS private IP address towards the private network\n    description: Private IP address that is assigned to the vDNS to communicate with the vLoadBalancer\n  vdns_private_ip_1:\n    type: string\n    label: vDNS private IP address towards the ECOMP management network\n    description: Private IP address that is assigned to the vDNS to communicate with ECOMP components\n  vlb_name_0:\n    type: string\n    label: vLoadBalancer name\n    description: Name of the vLoadBalancer\n  vdns_name_0:\n    type: string\n    label: vDNS name\n    description: Name of the vDNS\n  vnf_id:\n    type: string\n    label: VNF ID\n    description: The VNF ID is provided by ECOMP\n  vf_module_id:\n    type: string\n    label: vFirewall module ID\n    description: The vLoadBalancer Module ID is provided by ECOMP\n  webserver_ip:\n    type: string\n    label: Webserver IP address\n    description: IP address of the webserver that hosts the source code and binaries\n  dcae_collector_ip:\n    type: string\n    label: DCAE collector IP address\n    description: IP address of the DCAE collector\n  key_name:\n    type: string\n    label: Key pair name\n    description: Public/Private key pair name\n  pub_key:\n    type: string\n    label: Public key\n    description: Public key to be installed on the compute instance\n\nresources:\n  my_keypair:\n    type: OS::Nova::KeyPair\n    properties:\n      name: { get_param: key_name }\n      public_key: { get_param: pub_key }\n      save_private_key: false\n\n  vlb_private_network:\n    type: OS::Neutron::Net\n    properties:\n      name: { get_param: vlb_private_net_id }\n\n  vlb_private_subnet:\n    type: OS::Neutron::Subnet\n    properties:\n      name: { get_param: vlb_private_net_id }\n      network_id: { get_resource: vlb_private_network }\n      cidr: { get_param: vlb_private_net_cidr }\n\n  vlb_0:\n    type: OS::Nova::Server\n    properties:\n      image: { get_param: vlb_image_name }\n      flavor: { get_param: vlb_flavor_name }\n      name: { get_param: vlb_name_0 }\n      key_name: { get_resource: my_keypair }\n      networks:\n        - network: { get_param: public_net_id }\n        - port: { get_resource: vlb_private_0_port }\n        - port: { get_resource: vlb_private_1_port }\n      metadata: {vnf_id: { get_param: vnf_id }, vf_module_id: { get_param: vf_module_id }}\n      user_data_format: RAW\n      user_data:\n        str_replace:\n          params:\n            __webserver__: { get_param: webserver_ip }\n            __dcae_collector_ip__: { get_param: dcae_collector_ip }\n            __local_private_ipaddr__: { get_param: vlb_private_ip_0 }\n          template: |\n            #!/bin/bash\n\n            WEBSERVER_IP=__webserver__\n            DCAE_COLLECTOR_IP=__dcae_collector_ip__\n            LOCAL_PRIVATE_IPADDR=__local_private_ipaddr__\n\n            mkdir /opt/config\n            cd /opt\n            wget http://$WEBSERVER_IP/demo_repo/v_lb_init.sh\n            wget http://$WEBSERVER_IP/demo_repo/vlb.sh\n            chmod +x v_lb_init.sh\n            chmod +x vlb.sh\n            echo $WEBSERVER_IP > config/webserver_ip.txt\n            echo $DCAE_COLLECTOR_IP > config/dcae_collector_ip.txt\n            echo $LOCAL_PRIVATE_IPADDR > config/local_private_ipaddr.txt\n            echo \"no\" > config/install.txt\n            LOCAL_PUBLIC_IPADDR=$(ifconfig eth0 | grep \"inet addr\" | tr -s \' \' | cut -d\' \' -f3 | cut -d\':\' -f2)\n            echo $LOCAL_PUBLIC_IPADDR > config/local_public_ipaddr.txt\n            mv vlb.sh /etc/init.d\n            update-rc.d vlb.sh defaults\n            ./v_lb_init.sh\n\n  vlb_private_0_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_resource: vlb_private_network }\n      fixed_ips: [{\"subnet\": { get_resource: vlb_private_subnet }, \"ip_address\": { get_param: vlb_private_ip_0 }}]\n\n  vlb_private_1_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_param: ecomp_private_net_id }\n      fixed_ips: [{\"subnet\": { get_param: ecomp_private_net_id }, \"ip_address\": { get_param: vlb_private_ip_1 }}]\n\n  vdns_0:\n    type: OS::Nova::Server\n    properties:\n      image: { get_param: vlb_image_name }\n      flavor: { get_param: vlb_flavor_name }\n      name: { get_param: vdns_name_0 }\n      key_name: { get_resource: my_keypair }\n      networks:\n        - network: { get_param: public_net_id }\n        - port: { get_resource: vdns_private_0_port }\n        - port: { get_resource: vdns_private_1_port }\n      metadata: {vnf_id: { get_param: vnf_id }, vf_module_id: { get_param: vf_module_id }}\n      user_data_format: RAW\n      user_data:\n        str_replace:\n          params:\n            __webserver__: { get_param: webserver_ip }\n            __lb_oam_int__ : { get_param: vlb_private_ip_1 }\n            __lb_private_ipaddr__: { get_param: vlb_private_ip_0 }\n            __local_private_ipaddr__: { get_param: vdns_private_ip_0 }\n          template: |\n            #!/bin/bash\n\n            WEBSERVER_IP=__webserver__\n            LB_OAM_INT=__lb_oam_int__\n            LB_PRIVATE_IPADDR=__lb_private_ipaddr__\n            LOCAL_PRIVATE_IPADDR=__local_private_ipaddr__\n\n            mkdir /opt/config\n            cd /opt\n            wget http://$WEBSERVER_IP/demo_repo/v_dns_init.sh\n            wget http://$WEBSERVER_IP/demo_repo/vdns.sh\n            chmod +x v_dns_init.sh\n            chmod +x vdns.sh\n            echo $WEBSERVER_IP > config/webserver_ip.txt\n            echo $LB_OAM_INT > config/lb_oam_int.txt\n            echo $LB_PRIVATE_IPADDR > config/lb_private_ipaddr.txt\n            echo $LOCAL_PRIVATE_IPADDR > config/local_private_ipaddr.txt\n            echo \"no\" > config/install.txt\n            mv vdns.sh /etc/init.d\n            update-rc.d vdns.sh defaults\n            ./v_dns_init.sh\n\n  vdns_private_0_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_resource: vlb_private_network }\n      fixed_ips: [{\"subnet\": { get_resource: vlb_private_subnet }, \"ip_address\": { get_param: vdns_private_ip_0 }}]\n\n  vdns_private_1_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_param: ecomp_private_net_id }\n      fixed_ips: [{\"subnet\": { get_param: ecomp_private_net_id }, \"ip_address\": { get_param: vdns_private_ip_1 }}]\n',300,'MANUAL RECORD','2016-11-14 13:04:07');
-
-INSERT INTO `heat_template` (`ARTIFACT_UUID`, `NAME`, `VERSION`, `DESCRIPTION`, `BODY`, `TIMEOUT_MINUTES`, `ARTIFACT_CHECKSUM`, `CREATION_TIMESTAMP`) VALUES ('Artifact-UUID2','dnsscaling.yaml','1.0','DNS Scaling Heat','heat_template_version: 2013-05-23\n\ndescription: Heat template to deploy a vDNS for OpenECOMP (scaling-up scenario)\n\nparameters:\n  vlb_image_name:\n    type: string\n    label: Image name or ID\n    description: Image to be used for compute instance\n  vlb_flavor_name:\n    type: string\n    label: Flavor\n    description: Type of instance (flavor) to be used\n  public_net_id:\n    type: string\n    label: Public network name or ID\n    description: Public network that enables remote connection to VNF\n  vlb_private_net_id:\n    type: string\n    label: vLoadBalancer private network name or ID\n    description: Private network that connects vLoadBalancer with vDNSs\n  ecomp_private_net_id:\n    type: string\n    label: ECOMP management network name or ID\n    description: Private network that connects ECOMP component and the VNF\n  vlb_private_ip_0:\n    type: string\n    label: vLoadBalancer private IP address towards the private network\n    description: Private IP address that is assigned to the vLoadBalancer to communicate with the vDNSs\n  vlb_private_ip_1:\n    type: string\n    label: vLoadBalancer private IP address towards the ECOMP management network\n    description: Private IP address that is assigned to the vLoadBalancer to communicate with ECOMP components\n  vdns_private_ip_0:\n    type: string\n    label: vDNS private IP address towards the private network\n    description: Private IP address that is assigned to the vDNS to communicate with the vLoadBalancer\n  vdns_private_ip_1:\n    type: string\n    label: vDNS private IP address towards the ECOMP management network\n    description: Private IP address that is assigned to the vDNS to communicate with ECOMP components\n  vdns_name_0:\n    type: string\n    label: vDNS name\n    description: Name of the vDNS\n  vnf_id:\n    type: string\n    label: VNF ID\n    description: The VNF ID is provided by ECOMP\n  vf_module_id:\n    type: string\n    label: vFirewall module ID\n    description: The vLoadBalancer Module ID is provided by ECOMP\n  webserver_ip:\n    type: string\n    label: Webserver IP address\n    description: IP address of the webserver that hosts the source code and binaries\n  dcae_collector_ip:\n    type: string\n    label: DCAE collector IP address\n    description: IP address of the DCAE collector\n  key_name:\n    type: string\n    label: Key pair name\n    description: Public/Private key pair name\n  pub_key:\n    type: string\n    label: Public key\n    description: Public key to be installed on the compute instance\n\nresources:\n  vdns_0:\n    type: OS::Nova::Server\n    properties:\n      image: { get_param: vlb_image_name }\n      flavor: { get_param: vlb_flavor_name }\n      name: { get_param: vdns_name_0 }\n      key_name: { get_param: key_name }\n      networks:\n        - network: { get_param: public_net_id }\n        - port: { get_resource: vdns_private_0_port }\n        - port: { get_resource: vdns_private_1_port }\n      metadata: {vnf_id: { get_param: vnf_id }, vf_module_id: { get_param: vf_module_id }}\n      user_data_format: RAW\n      user_data:\n        str_replace:\n          params:\n            __webserver__: { get_param: webserver_ip }\n            __lb_oam_int__ : { get_param: vlb_private_ip_1 }\n            __lb_private_ipaddr__: { get_param: vlb_private_ip_0 }\n            __local_private_ipaddr__: { get_param: vdns_private_ip_0 }\n          template: |\n            #!/bin/bash\n\n            WEBSERVER_IP=__webserver__\n            LB_OAM_INT=__lb_oam_int__\n            LB_PRIVATE_IPADDR=__lb_private_ipaddr__\n            LOCAL_PRIVATE_IPADDR=__local_private_ipaddr__\n\n            mkdir /opt/config\n            cd /opt\n            wget http://$WEBSERVER_IP/demo_repo/v_dns_init.sh\n            wget http://$WEBSERVER_IP/demo_repo/vdns.sh\n            chmod +x v_dns_init.sh\n            chmod +x vdns.sh\n            echo $WEBSERVER_IP > config/webserver_ip.txt\n            echo $LB_OAM_INT > config/lb_oam_int.txt\n            echo $LB_PRIVATE_IPADDR > config/lb_private_ipaddr.txt\n            echo $LOCAL_PRIVATE_IPADDR > config/local_private_ipaddr.txt\n            echo \"no\" > config/install.txt\n            mv vdns.sh /etc/init.d\n            update-rc.d vdns.sh defaults\n            ./v_dns_init.sh\n\n  vdns_private_0_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_param: vlb_private_net_id }\n      fixed_ips: [{\"subnet\": { get_param: vlb_private_net_id }, \"ip_address\": { get_param: vdns_private_ip_0 }}]\n\n  vdns_private_1_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_param: ecomp_private_net_id }\n      fixed_ips: [{\"subnet\": { get_param: ecomp_private_net_id }, \"ip_address\": { get_param: vdns_private_ip_1 }}]\n',300,'MANUAL RECORD','2016-11-14 13:04:07');
-
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','dcae_collector_ip','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','ecomp_private_net_cidr','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','ecomp_private_net_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','key_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','public_net_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','pub_key','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vdns_private_ip_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vdns_private_ip_1','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vdsn_name_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vf_module_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vlb_flavor_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vlb_image_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vlb_name_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vlb_private_ip_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vlb_private_ip_1','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vlb_private_net_cidr','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vlb_private_net_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','vnf_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID1','webserver_ip','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','dcae_collector_ip','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','ecomp_private_net_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','key_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','public_net_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','pub_key','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','vdns_private_ip_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','vdns_private_ip_1','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','vdsn_name_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','vf_module_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','vlb_flavor_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','vlb_image_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','vlb_private_ip_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','vlb_private_net_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','vnf_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID2','webserver_ip','','string',NULL);
-
-INSERT INTO `service` (`MODEL_UUID`, `MODEL_NAME`, `MODEL_INVARIANT_UUID`, `MODEL_VERSION`, `DESCRIPTION`, `CREATION_TIMESTAMP`, `TOSCA_CSAR_ARTIFACT_UUID`) VALUES ('1e34774e-715e-4fd6-bd09-7b654622f35i','dns-service','585822c8-4027-4f84-ba50-e9248606f111','1.0','dns service for unit test','2016-11-14 13:04:07',NULL);
-
-INSERT INTO `service_to_resource_customizations` (`SERVICE_MODEL_UUID`, `RESOURCE_MODEL_CUSTOMIZATION_UUID`, `MODEL_TYPE`, `CREATION_TIMESTAMP`) VALUES ('1e34774e-715e-4fd6-bd09-7b654622f35i','302aa6be-a9fe-11e7-8b4b-0242ac120002','vnf','2017-10-05 18:51:28');
-
-INSERT INTO `vf_module` (`MODEL_UUID`, `MODEL_INVARIANT_UUID`, `MODEL_VERSION`, `MODEL_NAME`, `DESCRIPTION`, `IS_BASE`, `HEAT_TEMPLATE_ARTIFACT_UUID`, `VOL_HEAT_TEMPLATE_ARTIFACT_UUID`, `CREATION_TIMESTAMP`, `VNF_RESOURCE_MODEL_UUID`) VALUES ('1e34774e-715e-4fd5-bd08-7b654622f33e.VF_RI1_DNS::module-1::module-1.group','585822c7-4027-4f84-ba50-e9248606f132','1.0','VF_RI1_DNS::module-1',NULL,1,'Artifact-UUID1',NULL,'2016-11-14 13:04:07','585822c7-4027-4f84-ba50-e9248606f131');
-INSERT INTO `vf_module` (`MODEL_UUID`, `MODEL_INVARIANT_UUID`, `MODEL_VERSION`, `MODEL_NAME`, `DESCRIPTION`, `IS_BASE`, `HEAT_TEMPLATE_ARTIFACT_UUID`, `VOL_HEAT_TEMPLATE_ARTIFACT_UUID`, `CREATION_TIMESTAMP`, `VNF_RESOURCE_MODEL_UUID`) VALUES ('1e34774e-715e-4fd5-bd08-7b654622f33e.VF_RI1_DNS::module-2::module-1.group','585822c7-4027-4f84-ba50-e9248606f133','1.0','VF_RI1_DNS::module-2',NULL,0,'Artifact-UUID2',NULL,'2016-11-14 13:04:07','585822c7-4027-4f84-ba50-e9248606f131');
-
-INSERT INTO `vf_module_customization` (`MODEL_CUSTOMIZATION_UUID`, `LABEL`, `INITIAL_COUNT`, `MIN_INSTANCES`, `MAX_INSTANCES`, `AVAILABILITY_ZONE_COUNT`, `HEAT_ENVIRONMENT_ARTIFACT_UUID`, `VOL_ENVIRONMENT_ARTIFACT_UUID`, `CREATION_TIMESTAMP`, `VF_MODULE_MODEL_UUID`) VALUES ('30316d81-a9fe-11e7-8b4b-0242ac120002',NULL,1,0,NULL,NULL,'EnvArtifact-UUID1',NULL,'2017-10-05 18:51:25','1e34774e-715e-4fd5-bd08-7b654622f33e.VF_RI1_DNS::module-1::module-1.group');
-INSERT INTO `vf_module_customization` (`MODEL_CUSTOMIZATION_UUID`, `LABEL`, `INITIAL_COUNT`, `MIN_INSTANCES`, `MAX_INSTANCES`, `AVAILABILITY_ZONE_COUNT`, `HEAT_ENVIRONMENT_ARTIFACT_UUID`, `VOL_ENVIRONMENT_ARTIFACT_UUID`, `CREATION_TIMESTAMP`, `VF_MODULE_MODEL_UUID`) VALUES ('303170ae-a9fe-11e7-8b4b-0242ac120002',NULL,0,0,NULL,NULL,'EnvArtifact-UUID2',NULL,'2017-10-05 18:51:25','1e34774e-715e-4fd5-bd08-7b654622f33e.VF_RI1_DNS::module-2::module-1.group');
-INSERT INTO `vnf_res_custom_to_vf_module_custom` (`VNF_RESOURCE_CUST_MODEL_CUSTOMIZATION_UUID`, `VF_MODULE_CUST_MODEL_CUSTOMIZATION_UUID`, `CREATION_TIMESTAMP`) VALUES ('302aa6be-a9fe-11e7-8b4b-0242ac120002','30316d81-a9fe-11e7-8b4b-0242ac120002','2017-10-05 18:51:26');
-
-INSERT INTO `vnf_res_custom_to_vf_module_custom` (`VNF_RESOURCE_CUST_MODEL_CUSTOMIZATION_UUID`, `VF_MODULE_CUST_MODEL_CUSTOMIZATION_UUID`, `CREATION_TIMESTAMP`) VALUES ('302aa6be-a9fe-11e7-8b4b-0242ac120002','303170ae-a9fe-11e7-8b4b-0242ac120002','2017-10-05 18:51:26');
-
-INSERT INTO `vnf_resource` (`ORCHESTRATION_MODE`, `DESCRIPTION`, `CREATION_TIMESTAMP`, `MODEL_UUID`, `AIC_VERSION_MIN`, `AIC_VERSION_MAX`, `MODEL_INVARIANT_UUID`, `MODEL_VERSION`, `MODEL_NAME`, `TOSCA_NODE_TYPE`, `HEAT_TEMPLATE_ARTIFACT_UUID`) VALUES ('HEAT','dns service for unit test1707MIGRATED','2016-11-14 13:04:07','585822c7-4027-4f84-ba50-e9248606f131',NULL,NULL,'585822c7-4027-4f84-ba50-e9248606f112','1.0','DNSResource',NULL,NULL);
-
-INSERT INTO `vnf_resource_customization` (`MODEL_CUSTOMIZATION_UUID`, `MODEL_INSTANCE_NAME`, `MIN_INSTANCES`, `MAX_INSTANCES`, `AVAILABILITY_ZONE_MAX_COUNT`, `NF_TYPE`, `NF_ROLE`, `NF_FUNCTION`, `NF_NAMING_CODE`, `CREATION_TIMESTAMP`, `VNF_RESOURCE_MODEL_UUID`) VALUES ('302aa6be-a9fe-11e7-8b4b-0242ac120002','DNSResource-1',NULL,NULL,NULL,NULL,NULL,NULL,NULL,'2017-10-05 18:51:25','585822c7-4027-4f84-ba50-e9248606f131');
-
-SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
diff --git a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-vfw/create_mso_db-demo-vfw.sql b/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-vfw/create_mso_db-demo-vfw.sql
deleted file mode 100644
index 3206efc..0000000
--- a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-vfw/create_mso_db-demo-vfw.sql
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright © 2017 AT&T, Amdocs, Bell Canada
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*       http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-SOURCE ../default/create_mso_db-default.sql
-
-USE `mso_requests`;
-DROP USER 'mso';
-CREATE USER 'mso';
-GRANT ALL on mso_requests.* to 'mso' identified by 'mso123' with GRANT OPTION;
-FLUSH PRIVILEGES;
-
-USE `mso_catalog`;
-DROP USER 'catalog';
-CREATE USER 'catalog';
-GRANT ALL on mso_catalog.* to 'catalog' identified by 'catalog123' with GRANT OPTION;
-FLUSH PRIVILEGES;
-
-SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
-
-INSERT INTO `heat_environment` (`ARTIFACT_UUID`, `NAME`, `VERSION`, `DESCRIPTION`, `BODY`, `ARTIFACT_CHECKSUM`, `CREATION_TIMESTAMP`) VALUES ('EnvArtifact-UUID3','base_vfw.env','1.0','base_vfw ENV file','parameters:\n  vfw_image_name: Ubuntu 14.04 LTS (Trusty Tahr) (PVHVM)\n  vfw_flavor_name: 4 GB General Purpose v1\n  public_net_id: 00000000-0000-0000-0000-000000000000\n  unprotected_private_net_id: zdfw1fwl01_unprotected\n  protected_private_net_id: zdfw1fwl01_protected\n  ecomp_private_net_id: oam_ecomp\n  unprotected_private_net_cidr: 192.168.10.0/24\n  protected_private_net_cidr: 192.168.20.0/24\n  ecomp_private_net_cidr: 192.168.9.0/24\n  vfw_private_ip_0: 192.168.10.100\n  vfw_private_ip_1: 192.168.20.100\n  vfw_private_ip_2: 192.168.9.100\n  vpg_private_ip_0: 192.168.10.200\n  vpg_private_ip_1: 192.168.9.200\n  vsn_private_ip_0: 192.168.20.250\n  vsn_private_ip_1: 192.168.9.250\n  vfw_name_0: zdfw1fwl01fwl01\n  vpg_name_0: zdfw1fwl01pgn01\n  vsn_name_0: zdfw1fwl01snk01\n  vnf_id: vFirewall_demo_app\n  vf_module_id: vFirewall\n  webserver_ip: 162.242.237.182\n  dcae_collector_ip: 192.168.9.1\n  key_name: vfw_key\n  pub_key: INSERT YOUR PUBLIC KEY HERE','MANUAL RECORD','2016-11-14 13:04:07');
-
-INSERT INTO `heat_template` (`ARTIFACT_UUID`, `NAME`, `VERSION`, `DESCRIPTION`, `BODY`, `TIMEOUT_MINUTES`, `ARTIFACT_CHECKSUM`, `CREATION_TIMESTAMP`) VALUES ('Artifact-UUID3','base_vfw.yaml','1.0','Base VFW Heat','heat_template_version: 2013-05-23\n\ndescription: Heat template to deploy vFirewall demo app for OpenECOMP\n\nparameters:\n  vfw_image_name:\n    type: string\n    label: Image name or ID\n    description: Image to be used for compute instance\n  vfw_flavor_name:\n    type: string\n    label: Flavor\n    description: Type of instance (flavor) to be used\n  public_net_id:\n    type: string\n    label: Public network name or ID\n    description: Public network that enables remote connection to VNF\n  unprotected_private_net_id:\n    type: string\n    label: Unprotected private network name or ID\n    description: Private network that connects vPacketGenerator with vFirewall\n  protected_private_net_id:\n    type: string\n    label: Protected private network name or ID\n    description: Private network that connects vFirewall with vSink\n  ecomp_private_net_id:\n    type: string\n    label: ECOMP management network name or ID\n    description: Private network that connects ECOMP component and the VNF\n  unprotected_private_net_cidr:\n    type: string\n    label: Unprotected private network CIDR\n    description: The CIDR of the unprotected private network\n  protected_private_net_cidr:\n    type: string\n    label: Protected private network CIDR\n    description: The CIDR of the protected private network\n  ecomp_private_net_cidr:\n    type: string\n    label: ECOMP private network CIDR\n    description: The CIDR of the protected private network\n  vfw_private_ip_0:\n    type: string\n    label: vFirewall private IP address towards the unprotected network\n    description: Private IP address that is assigned to the vFirewall to communicate with the vPacketGenerator\n  vfw_private_ip_1:\n    type: string\n    label: vFirewall private IP address towards the protected network\n    description: Private IP address that is assigned to the vFirewall to communicate with the vSink\n  vfw_private_ip_2:\n    type: string\n    label: vFirewall private IP address towards the ECOMP management network\n    description: Private IP address that is assigned to the vFirewall to communicate with ECOMP components\n  vpg_private_ip_0:\n    type: string\n    label: vPacketGenerator private IP address towards the unprotected network\n    description: Private IP address that is assigned to the vPacketGenerator to communicate with the vFirewall\n  vpg_private_ip_1:\n    type: string\n    label: vPacketGenerator private IP address towards the ECOMP management network\n    description: Private IP address that is assigned to the vPacketGenerator to communicate with ECOMP components\n  vsn_private_ip_0:\n    type: string\n    label: vSink private IP address towards the protected network\n    description: Private IP address that is assigned to the vSink to communicate with the vFirewall\n  vsn_private_ip_1:\n    type: string\n    label: vSink private IP address towards the ECOMP management network\n    description: Private IP address that is assigned to the vSink to communicate with ECOMP components\n  vfw_name_0:\n    type: string\n    label: vFirewall name\n    description: Name of the vFirewall\n  vpg_name_0:\n    type: string\n    label: vPacketGenerator name\n    description: Name of the vPacketGenerator\n  vsn_name_0:\n    type: string\n    label: vSink name\n    description: Name of the vSink\n  vnf_id:\n    type: string\n    label: VNF ID\n    description: The VNF ID is provided by ECOMP\n  vf_module_id:\n    type: string\n    label: vFirewall module ID\n    description: The vFirewall Module ID is provided by ECOMP\n  webserver_ip:\n    type: string\n    label: Webserver IP address\n    description: IP address of the webserver that hosts the source code and binaries\n  dcae_collector_ip:\n    type: string\n    label: DCAE collector IP address\n    description: IP address of the DCAE collector\n  key_name:\n    type: string\n    label: Key pair name\n    description: Public/Private key pair name\n  pub_key:\n    type: string\n    label: Public key\n    description: Public key to be installed on the compute instance\n\nresources:\n  my_keypair:\n    type: OS::Nova::KeyPair\n    properties:\n      name: { get_param: key_name }\n      public_key: { get_param: pub_key }\n      save_private_key: false\n\n  unprotected_private_network:\n    type: OS::Neutron::Net\n    properties:\n      name: { get_param: unprotected_private_net_id }\n\n  protected_private_network:\n    type: OS::Neutron::Net\n    properties:\n      name: { get_param: protected_private_net_id }\n\n  unprotected_private_subnet:\n    type: OS::Neutron::Subnet\n    properties:\n      network_id: { get_resource: unprotected_private_network }\n      cidr: { get_param: unprotected_private_net_cidr }\n\n  protected_private_subnet:\n    type: OS::Neutron::Subnet\n    properties:\n      network_id: { get_resource: protected_private_network }\n      cidr: { get_param: protected_private_net_cidr }\n\n  vfw_0:\n    type: OS::Nova::Server\n    properties:\n      image: { get_param: vfw_image_name }\n      flavor: { get_param: vfw_flavor_name }\n      name: { get_param: vfw_name_0 }\n      key_name: { get_resource: my_keypair }\n      networks:\n        - network: { get_param: public_net_id }\n        - port: { get_resource: vfw_private_0_port }\n        - port: { get_resource: vfw_private_1_port }\n        - port: { get_resource: vfw_private_2_port }\n      metadata: {vnf_id: { get_param: vnf_id }, vf_module_id: { get_param: vf_module_id }}\n      user_data_format: RAW\n      user_data:\n        str_replace:\n          params:\n            __webserver__: { get_param: webserver_ip }\n            __dcae_collector_ip__ : { get_param: dcae_collector_ip }\n          template: |\n            #!/bin/bash\n\n            WEBSERVER_IP=__webserver__\n            DCAE_COLLECTOR_IP=__dcae_collector_ip__\n\n            mkdir /opt/config\n            cd /opt\n            wget http://$WEBSERVER_IP/demo_repo/v_firewall_init.sh\n            wget http://$WEBSERVER_IP/demo_repo/vfirewall.sh\n            chmod +x v_firewall_init.sh\n            chmod +x vfirewall.sh\n            echo $WEBSERVER_IP > config/webserver_ip.txt\n            echo $DCAE_COLLECTOR_IP > config/dcae_collector_ip.txt\n            echo \"no\" > config/install.txt\n            mv vfirewall.sh /etc/init.d\n            sudo update-rc.d vfirewall.sh defaults\n            ./v_firewall_init.sh\n\n  vfw_private_0_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_resource: unprotected_private_network }\n      fixed_ips: [{\"subnet\": { get_resource: unprotected_private_subnet }, \"ip_address\": { get_param: vfw_private_ip_0 }}]\n\n  vfw_private_1_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_resource: protected_private_network }\n      fixed_ips: [{\"subnet\": { get_resource: protected_private_subnet }, \"ip_address\": { get_param: vfw_private_ip_1 }}]\n\n  vfw_private_2_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_param: ecomp_private_net_id }\n      fixed_ips: [{\"subnet\": { get_param: ecomp_private_net_id }, \"ip_address\": { get_param: vfw_private_ip_2 }}]\n\n  vpg_0:\n    type: OS::Nova::Server\n    properties:\n      image: { get_param: vfw_image_name }\n      flavor: { get_param: vfw_flavor_name }\n      name: { get_param: vpg_name_0 }\n      key_name: { get_resource: my_keypair }\n      networks:\n        - network: { get_param: public_net_id }\n        - port: { get_resource: vpg_private_0_port }\n        - port: { get_resource: vpg_private_1_port }\n      metadata: {vnf_id: { get_param: vnf_id }, vf_module_id: { get_param: vf_module_id }}\n      user_data_format: RAW\n      user_data:\n        str_replace:\n          params:\n            __webserver__: { get_param: webserver_ip }\n            __fw_ipaddr__: { get_param: vfw_private_ip_0 }\n            __protected_net_cidr__: { get_param: protected_private_net_cidr }\n            __sink_ipaddr__: { get_param: vsn_private_ip_0 }\n          template: |\n            #!/bin/bash\n\n            WEBSERVER_IP=__webserver__\n            FW_IPADDR=__fw_ipaddr__\n            PROTECTED_NET_CIDR=__protected_net_cidr__\n            SINK_IPADDR=__sink_ipaddr__\n\n            mkdir /opt/config\n            cd /opt\n            wget http://$WEBSERVER_IP/demo_repo/v_packetgen_init.sh\n            wget http://$WEBSERVER_IP/demo_repo/vpacketgen.sh\n            chmod +x v_packetgen_init.sh\n            chmod +x vpacketgen.sh\n            echo $WEBSERVER_IP > config/webserver_ip.txt\n            echo $FW_IPADDR > config/fw_ipaddr.txt\n            echo $PROTECTED_NET_CIDR > config/protected_net_cidr.txt\n            echo $SINK_IPADDR > config/sink_ipaddr.txt\n            echo \"no\" > config/install.txt\n            mv vpacketgen.sh /etc/init.d\n            sudo update-rc.d vpacketgen.sh defaults\n            ./v_packetgen_init.sh\n\n  vpg_private_0_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_resource: unprotected_private_network }\n      fixed_ips: [{\"subnet\": { get_resource: unprotected_private_subnet }, \"ip_address\": { get_param: vpg_private_ip_0 }}]\n\n  vpg_private_1_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_param: ecomp_private_net_id }\n      fixed_ips: [{\"subnet\": { get_param: ecomp_private_net_id }, \"ip_address\": { get_param: vpg_private_ip_1 }}]\n\n  vsn_0:\n    type: OS::Nova::Server\n    properties:\n      image: { get_param: vfw_image_name }\n      flavor: { get_param: vfw_flavor_name }\n      name: { get_param: vsn_name_0 }\n      key_name: { get_resource: my_keypair }\n      networks:\n        - network: { get_param: public_net_id }\n        - port: { get_resource: vsn_private_0_port }\n        - port: { get_resource: vsn_private_1_port }\n      metadata: {vnf_id: { get_param: vnf_id }, vf_module_id: { get_param: vf_module_id }}\n      user_data_format: RAW\n      user_data:\n        str_replace:\n          params:\n            __webserver__: { get_param: webserver_ip }\n            __protected_net_gw__: { get_param: vfw_private_ip_1 }\n            __unprotected_net__: { get_param: unprotected_private_net_cidr }\n          template: |\n            #!/bin/bash\n\n            WEBSERVER_IP=__webserver__\n            PROTECTED_NET_GW=__protected_net_gw__\n            UNPROTECTED_NET=__unprotected_net__\n            UNPROTECTED_NET=$(echo $UNPROTECTED_NET | cut -d\'/\' -f1)\n\n            mkdir /opt/config\n            cd /opt\n            wget http://$WEBSERVER_IP/demo_repo/v_sink_init.sh\n            wget http://$WEBSERVER_IP/demo_repo/vsink.sh\n            chmod +x v_sink_init.sh\n            chmod +x vsink.sh\n            echo $PROTECTED_NET_GW > config/protected_net_gw.txt\n            echo $UNPROTECTED_NET > config/unprotected_net.txt\n            echo \"no\" > config/install.txt\n            mv vsink.sh /etc/init.d\n            sudo update-rc.d vsink.sh defaults\n            ./v_sink_init.sh\n\n  vsn_private_0_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_resource: protected_private_network }\n      fixed_ips: [{\"subnet\": { get_resource: protected_private_subnet }, \"ip_address\": { get_param: vsn_private_ip_0 }}]\n\n  vsn_private_1_port:\n    type: OS::Neutron::Port\n    properties:\n      network: { get_param: ecomp_private_net_id }\n      fixed_ips: [{\"subnet\": { get_param: ecomp_private_net_id }, \"ip_address\": { get_param: vsn_private_ip_1 }}]\n \n',300,'MANUAL RECORD','2016-11-14 13:04:07');
-
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','dcae_collector_ip','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','ecomp_private_net_cidr','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','ecomp_private_net_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','key_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','protected_private_net_cidr','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','protected_private_net_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','public_net_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','pub_key','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','unprotected_private_net_cidr','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','unprotected_private_net_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vfw_flavor_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vfw_image_name','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vfw_name_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vfw_private_ip_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vfw_private_ip_1','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vfw_private_ip_2','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vf_module_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vnf_id','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vpg_name_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vpg_private_ip_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vpg_private_ip_1','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vsn_name_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vsn_private_ip_0','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','vsn_private_ip_1','','string',NULL);
-INSERT INTO `heat_template_params` (`HEAT_TEMPLATE_ARTIFACT_UUID`, `PARAM_NAME`, `IS_REQUIRED`, `PARAM_TYPE`, `PARAM_ALIAS`) VALUES ('Artifact-UUID3','webserver_ip','','string',NULL);
-
-INSERT INTO `service` (`MODEL_UUID`, `MODEL_NAME`, `MODEL_INVARIANT_UUID`, `MODEL_VERSION`, `DESCRIPTION`, `CREATION_TIMESTAMP`, `TOSCA_CSAR_ARTIFACT_UUID`) VALUES ('2e34774e-715e-4fd5-bd09-7b654622f35i','vfw-service','585822c7-4027-4f84-ba50-e9248606f112','1.0','VFW service','2016-11-14 13:04:07',NULL);
-
-INSERT INTO `vf_module` (`MODEL_UUID`, `MODEL_INVARIANT_UUID`, `MODEL_VERSION`, `MODEL_NAME`, `DESCRIPTION`, `IS_BASE`, `HEAT_TEMPLATE_ARTIFACT_UUID`, `VOL_HEAT_TEMPLATE_ARTIFACT_UUID`, `CREATION_TIMESTAMP`, `VNF_RESOURCE_MODEL_UUID`) VALUES ('1e34774e-715e-4fd5-bd08-7b654622f33f.VF_RI1_VFW::module-1::module-1.group','585822c7-4027-4f84-ba50-e9248606f134','1.0','VF_RI1_VFW::module-1',NULL,1,'Artifact-UUID3',NULL,'2016-11-14 13:04:07','685822c7-4027-4f84-ba50-e9248606f132');
-
-INSERT INTO `vf_module_customization` (`MODEL_CUSTOMIZATION_UUID`, `LABEL`, `INITIAL_COUNT`, `MIN_INSTANCES`, `MAX_INSTANCES`, `AVAILABILITY_ZONE_COUNT`, `HEAT_ENVIRONMENT_ARTIFACT_UUID`, `VOL_ENVIRONMENT_ARTIFACT_UUID`, `CREATION_TIMESTAMP`, `VF_MODULE_MODEL_UUID`) VALUES ('5aa23938-a9fe-11e7-8b4b-0242ac120002',NULL,1,0,NULL,NULL,'EnvArtifact-UUID3',NULL,'2017-10-05 18:52:03','1e34774e-715e-4fd5-bd08-7b654622f33f.VF_RI1_VFW::module-1::module-1.group');
-
-INSERT INTO `vnf_res_custom_to_vf_module_custom` (`VNF_RESOURCE_CUST_MODEL_CUSTOMIZATION_UUID`, `VF_MODULE_CUST_MODEL_CUSTOMIZATION_UUID`, `CREATION_TIMESTAMP`) VALUES ('5a9bd247-a9fe-11e7-8b4b-0242ac120002','5aa23938-a9fe-11e7-8b4b-0242ac120002','2017-10-05 18:52:03');
-
-INSERT INTO `vnf_resource` (`ORCHESTRATION_MODE`, `DESCRIPTION`, `CREATION_TIMESTAMP`, `MODEL_UUID`, `AIC_VERSION_MIN`, `AIC_VERSION_MAX`, `MODEL_INVARIANT_UUID`, `MODEL_VERSION`, `MODEL_NAME`, `TOSCA_NODE_TYPE`, `HEAT_TEMPLATE_ARTIFACT_UUID`) VALUES ('HEAT','VFW service1707MIGRATED','2016-11-14 13:04:07','685822c7-4027-4f84-ba50-e9248606f132',NULL,NULL,'585822c7-4027-4f84-ba50-e9248606f113','1.0','VFWResource',NULL,NULL);
-
-INSERT INTO `vnf_resource_customization` (`MODEL_CUSTOMIZATION_UUID`, `MODEL_INSTANCE_NAME`, `MIN_INSTANCES`, `MAX_INSTANCES`, `AVAILABILITY_ZONE_MAX_COUNT`, `NF_TYPE`, `NF_ROLE`, `NF_FUNCTION`, `NF_NAMING_CODE`, `CREATION_TIMESTAMP`, `VNF_RESOURCE_MODEL_UUID`) VALUES ('5a9bd247-a9fe-11e7-8b4b-0242ac120002','VFWResource-1',NULL,NULL,NULL,NULL,NULL,NULL,NULL,'2017-10-05 18:52:03','685822c7-4027-4f84-ba50-e9248606f132');
-
-SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
diff --git a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/camunda/mariadb_engine_7.7.3-ee.sql b/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/camunda/mariadb_engine_7.7.3-ee.sql
deleted file mode 100644
index b7adb4e..0000000
--- a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/camunda/mariadb_engine_7.7.3-ee.sql
+++ /dev/null
@@ -1,1210 +0,0 @@
-/* Copyright © 2017 AT&T, Amdocs, Bell Canada
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*       http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-DROP DATABASE IF EXISTS `camundabpmn`;
-
-CREATE DATABASE `camundabpmn`;
-
-USE `camundabpmn`;
-
-# DROP USER IF EXISTS 'camunda';
-delete from mysql.user where User='camunda';
-CREATE USER 'camunda';
-GRANT ALL on camundabpmn.* to 'camunda' identified by 'camunda123' with GRANT OPTION;
-FLUSH PRIVILEGES;
-
-USE `camundabpmn`;
-
-create table ACT_GE_PROPERTY (
-    NAME_ varchar(64),
-    VALUE_ varchar(300),
-    REV_ integer,
-    primary key (NAME_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-insert into ACT_GE_PROPERTY
-values ('schema.version', 'fox', 1);
-
-insert into ACT_GE_PROPERTY
-values ('schema.history', 'create(fox)', 1);
-
-insert into ACT_GE_PROPERTY
-values ('next.dbid', '1', 1);
-
-insert into ACT_GE_PROPERTY
-values ('deployment.lock', '0', 1);
-
-insert into ACT_GE_PROPERTY
-values ('history.cleanup.job.lock', '0', 1);
-
-create table ACT_GE_BYTEARRAY (
-    ID_ varchar(64),
-    REV_ integer,
-    NAME_ varchar(255),
-    DEPLOYMENT_ID_ varchar(64),
-    BYTES_ LONGBLOB,
-    GENERATED_ TINYINT,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RE_DEPLOYMENT (
-    ID_ varchar(64),
-    NAME_ varchar(255),
-    DEPLOY_TIME_ timestamp(3),
-    SOURCE_ varchar(255),
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_EXECUTION (
-    ID_ varchar(64),
-    REV_ integer,
-    PROC_INST_ID_ varchar(64),
-    BUSINESS_KEY_ varchar(255),
-    PARENT_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    SUPER_EXEC_ varchar(64),
-    SUPER_CASE_EXEC_ varchar(64),
-    CASE_INST_ID_ varchar(64),
-    ACT_ID_ varchar(255),
-    ACT_INST_ID_ varchar(64),
-    IS_ACTIVE_ TINYINT,
-    IS_CONCURRENT_ TINYINT,
-    IS_SCOPE_ TINYINT,
-    IS_EVENT_SCOPE_ TINYINT,
-    SUSPENSION_STATE_ integer,
-    CACHED_ENT_STATE_ integer,
-    SEQUENCE_COUNTER_ bigint,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_JOB (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    TYPE_ varchar(255) NOT NULL,
-    LOCK_EXP_TIME_ timestamp(3) NULL,
-    LOCK_OWNER_ varchar(255),
-    EXCLUSIVE_ boolean,
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROCESS_DEF_ID_ varchar(64),
-    PROCESS_DEF_KEY_ varchar(255),
-    RETRIES_ integer,
-    EXCEPTION_STACK_ID_ varchar(64),
-    EXCEPTION_MSG_ varchar(4000),
-    DUEDATE_ timestamp(3) NULL,
-    REPEAT_ varchar(255),
-    HANDLER_TYPE_ varchar(255),
-    HANDLER_CFG_ varchar(4000),
-    DEPLOYMENT_ID_ varchar(64),
-    SUSPENSION_STATE_ integer NOT NULL DEFAULT 1,
-    JOB_DEF_ID_ varchar(64),
-    PRIORITY_ bigint NOT NULL DEFAULT 0,
-    SEQUENCE_COUNTER_ bigint,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_JOBDEF (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    PROC_DEF_ID_ varchar(64),
-    PROC_DEF_KEY_ varchar(255),
-    ACT_ID_ varchar(255),
-    JOB_TYPE_ varchar(255) NOT NULL,
-    JOB_CONFIGURATION_ varchar(255),
-    SUSPENSION_STATE_ integer,
-    JOB_PRIORITY_ bigint,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RE_PROCDEF (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    CATEGORY_ varchar(255),
-    NAME_ varchar(255),
-    KEY_ varchar(255) not null,
-    VERSION_ integer not null,
-    DEPLOYMENT_ID_ varchar(64),
-    RESOURCE_NAME_ varchar(4000),
-    DGRM_RESOURCE_NAME_ varchar(4000),
-    HAS_START_FORM_KEY_ TINYINT,
-    SUSPENSION_STATE_ integer,
-    TENANT_ID_ varchar(64),
-    VERSION_TAG_ varchar(64),
-    HISTORY_TTL_ integer,
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_TASK (
-    ID_ varchar(64),
-    REV_ integer,
-    EXECUTION_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    CASE_EXECUTION_ID_ varchar(64),
-    CASE_INST_ID_ varchar(64),
-    CASE_DEF_ID_ varchar(64),
-    NAME_ varchar(255),
-    PARENT_TASK_ID_ varchar(64),
-    DESCRIPTION_ varchar(4000),
-    TASK_DEF_KEY_ varchar(255),
-    OWNER_ varchar(255),
-    ASSIGNEE_ varchar(255),
-    DELEGATION_ varchar(64),
-    PRIORITY_ integer,
-    CREATE_TIME_ timestamp(3),
-    DUE_DATE_ datetime(3),
-    FOLLOW_UP_DATE_ datetime(3),
-    SUSPENSION_STATE_ integer,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_IDENTITYLINK (
-    ID_ varchar(64),
-    REV_ integer,
-    GROUP_ID_ varchar(255),
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_VARIABLE (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    TYPE_ varchar(255) not null,
-    NAME_ varchar(255) not null,
-    EXECUTION_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    CASE_EXECUTION_ID_ varchar(64),
-    CASE_INST_ID_ varchar(64),
-    TASK_ID_ varchar(64),
-    BYTEARRAY_ID_ varchar(64),
-    DOUBLE_ double,
-    LONG_ bigint,
-    TEXT_ LONGBLOB NULL,
-    TEXT2_ LONGBLOB NULL,
-    VAR_SCOPE_ varchar(64) not null,
-    SEQUENCE_COUNTER_ bigint,
-    IS_CONCURRENT_LOCAL_ TINYINT,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_EVENT_SUBSCR (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    EVENT_TYPE_ varchar(255) not null,
-    EVENT_NAME_ varchar(255),
-    EXECUTION_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    ACTIVITY_ID_ varchar(255),
-    CONFIGURATION_ varchar(255),
-    CREATED_ timestamp(3) not null,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_INCIDENT (
-  ID_ varchar(64) not null,
-  REV_ integer not null,
-  INCIDENT_TIMESTAMP_ timestamp(3) not null,
-  INCIDENT_MSG_ varchar(4000),
-  INCIDENT_TYPE_ varchar(255) not null,
-  EXECUTION_ID_ varchar(64),
-  ACTIVITY_ID_ varchar(255),
-  PROC_INST_ID_ varchar(64),
-  PROC_DEF_ID_ varchar(64),
-  CAUSE_INCIDENT_ID_ varchar(64),
-  ROOT_CAUSE_INCIDENT_ID_ varchar(64),
-  CONFIGURATION_ varchar(255),
-  TENANT_ID_ varchar(64),
-  JOB_DEF_ID_ varchar(64),
-  primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_AUTHORIZATION (
-  ID_ varchar(64) not null,
-  REV_ integer not null,
-  TYPE_ integer not null,
-  GROUP_ID_ varchar(255),
-  USER_ID_ varchar(255),
-  RESOURCE_TYPE_ integer not null,
-  RESOURCE_ID_ varchar(64),
-  PERMS_ integer,
-  primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_FILTER (
-  ID_ varchar(64) not null,
-  REV_ integer not null,
-  RESOURCE_TYPE_ varchar(255) not null,
-  NAME_ varchar(255) not null,
-  OWNER_ varchar(255),
-  QUERY_ LONGTEXT not null,
-  PROPERTIES_ LONGTEXT,
-  primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_METER_LOG (
-  ID_ varchar(64) not null,
-  NAME_ varchar(64) not null,
-  REPORTER_ varchar(255),
-  VALUE_ bigint,
-  TIMESTAMP_ timestamp(3),
-  MILLISECONDS_ bigint DEFAULT 0,
-  primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_EXT_TASK (
-  ID_ varchar(64) not null,
-  REV_ integer not null,
-  WORKER_ID_ varchar(255),
-  TOPIC_NAME_ varchar(255),
-  RETRIES_ integer,
-  ERROR_MSG_ varchar(4000),
-  ERROR_DETAILS_ID_ varchar(64),
-  LOCK_EXP_TIME_ timestamp(3) NULL,
-  SUSPENSION_STATE_ integer,
-  EXECUTION_ID_ varchar(64),
-  PROC_INST_ID_ varchar(64),
-  PROC_DEF_ID_ varchar(64),
-  PROC_DEF_KEY_ varchar(255),
-  ACT_ID_ varchar(255),
-  ACT_INST_ID_ varchar(64),
-  TENANT_ID_ varchar(64),
-  PRIORITY_ bigint NOT NULL DEFAULT 0,
-  primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_RU_BATCH (
-  ID_ varchar(64) not null,
-  REV_ integer not null,
-  TYPE_ varchar(255),
-  TOTAL_JOBS_ integer,
-  JOBS_CREATED_ integer,
-  JOBS_PER_SEED_ integer,
-  INVOCATIONS_PER_JOB_ integer,
-  SEED_JOB_DEF_ID_ varchar(64),
-  BATCH_JOB_DEF_ID_ varchar(64),
-  MONITOR_JOB_DEF_ID_ varchar(64),
-  SUSPENSION_STATE_ integer,
-  CONFIGURATION_ varchar(255),
-  TENANT_ID_ varchar(64),
-  primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create index ACT_IDX_EXEC_BUSKEY on ACT_RU_EXECUTION(BUSINESS_KEY_);
-create index ACT_IDX_EXEC_TENANT_ID on ACT_RU_EXECUTION(TENANT_ID_);
-create index ACT_IDX_TASK_CREATE on ACT_RU_TASK(CREATE_TIME_);
-create index ACT_IDX_TASK_ASSIGNEE on ACT_RU_TASK(ASSIGNEE_);
-create index ACT_IDX_TASK_TENANT_ID on ACT_RU_TASK(TENANT_ID_);
-create index ACT_IDX_IDENT_LNK_USER on ACT_RU_IDENTITYLINK(USER_ID_);
-create index ACT_IDX_IDENT_LNK_GROUP on ACT_RU_IDENTITYLINK(GROUP_ID_);
-create index ACT_IDX_EVENT_SUBSCR_CONFIG_ on ACT_RU_EVENT_SUBSCR(CONFIGURATION_);
-create index ACT_IDX_EVENT_SUBSCR_TENANT_ID on ACT_RU_EVENT_SUBSCR(TENANT_ID_);
-create index ACT_IDX_VARIABLE_TASK_ID on ACT_RU_VARIABLE(TASK_ID_);
-create index ACT_IDX_VARIABLE_TENANT_ID on ACT_RU_VARIABLE(TENANT_ID_);
-create index ACT_IDX_ATHRZ_PROCEDEF on ACT_RU_IDENTITYLINK(PROC_DEF_ID_);
-create index ACT_IDX_INC_CONFIGURATION on ACT_RU_INCIDENT(CONFIGURATION_);
-create index ACT_IDX_INC_TENANT_ID on ACT_RU_INCIDENT(TENANT_ID_);
--- CAM-5914
-create index ACT_IDX_JOB_EXECUTION_ID on ACT_RU_JOB(EXECUTION_ID_);
--- this index needs to be limited in mariadb see CAM-6938
-create index ACT_IDX_JOB_HANDLER on ACT_RU_JOB(HANDLER_TYPE_(100),HANDLER_CFG_(155));
-create index ACT_IDX_JOB_PROCINST on ACT_RU_JOB(PROCESS_INSTANCE_ID_);
-create index ACT_IDX_JOB_TENANT_ID on ACT_RU_JOB(TENANT_ID_);
-create index ACT_IDX_JOBDEF_TENANT_ID on ACT_RU_JOBDEF(TENANT_ID_);
-
--- new metric milliseconds column
-CREATE INDEX ACT_IDX_METER_LOG_MS ON ACT_RU_METER_LOG(MILLISECONDS_);
-CREATE INDEX ACT_IDX_METER_LOG_NAME_MS ON ACT_RU_METER_LOG(NAME_, MILLISECONDS_);
-CREATE INDEX ACT_IDX_METER_LOG_REPORT ON ACT_RU_METER_LOG(NAME_, REPORTER_, MILLISECONDS_);
-
--- old metric timestamp column
-CREATE INDEX ACT_IDX_METER_LOG_TIME ON ACT_RU_METER_LOG(TIMESTAMP_);
-CREATE INDEX ACT_IDX_METER_LOG ON ACT_RU_METER_LOG(NAME_, TIMESTAMP_);
-
-create index ACT_IDX_EXT_TASK_TOPIC on ACT_RU_EXT_TASK(TOPIC_NAME_);
-create index ACT_IDX_EXT_TASK_TENANT_ID on ACT_RU_EXT_TASK(TENANT_ID_);
-create index ACT_IDX_EXT_TASK_PRIORITY ON ACT_RU_EXT_TASK(PRIORITY_);
-create index ACT_IDX_EXT_TASK_ERR_DETAILS ON ACT_RU_EXT_TASK(ERROR_DETAILS_ID_);
-create index ACT_IDX_AUTH_GROUP_ID ON ACT_RU_AUTHORIZATION(GROUP_ID_);
-create index ACT_IDX_JOB_JOB_DEF_ID on ACT_RU_JOB(JOB_DEF_ID_);
-
-alter table ACT_GE_BYTEARRAY
-    add constraint ACT_FK_BYTEARR_DEPL
-    foreign key (DEPLOYMENT_ID_)
-    references ACT_RE_DEPLOYMENT (ID_);
-
-alter table ACT_RU_EXECUTION
-    add constraint ACT_FK_EXE_PROCINST
-    foreign key (PROC_INST_ID_)
-    references ACT_RU_EXECUTION (ID_) on delete cascade on update cascade;
-
-alter table ACT_RU_EXECUTION
-    add constraint ACT_FK_EXE_PARENT
-    foreign key (PARENT_ID_)
-    references ACT_RU_EXECUTION (ID_);
-
-alter table ACT_RU_EXECUTION
-    add constraint ACT_FK_EXE_SUPER
-    foreign key (SUPER_EXEC_)
-    references ACT_RU_EXECUTION (ID_);
-
-alter table ACT_RU_EXECUTION
-    add constraint ACT_FK_EXE_PROCDEF
-    foreign key (PROC_DEF_ID_)
-    references ACT_RE_PROCDEF (ID_);
-
-alter table ACT_RU_IDENTITYLINK
-    add constraint ACT_FK_TSKASS_TASK
-    foreign key (TASK_ID_)
-    references ACT_RU_TASK (ID_);
-
-alter table ACT_RU_IDENTITYLINK
-    add constraint ACT_FK_ATHRZ_PROCEDEF
-    foreign key (PROC_DEF_ID_)
-    references ACT_RE_PROCDEF(ID_);
-
-alter table ACT_RU_TASK
-    add constraint ACT_FK_TASK_EXE
-    foreign key (EXECUTION_ID_)
-    references ACT_RU_EXECUTION (ID_);
-
-alter table ACT_RU_TASK
-    add constraint ACT_FK_TASK_PROCINST
-    foreign key (PROC_INST_ID_)
-    references ACT_RU_EXECUTION (ID_);
-
-alter table ACT_RU_TASK
-  add constraint ACT_FK_TASK_PROCDEF
-  foreign key (PROC_DEF_ID_)
-  references ACT_RE_PROCDEF (ID_);
-
-alter table ACT_RU_VARIABLE
-    add constraint ACT_FK_VAR_EXE
-    foreign key (EXECUTION_ID_)
-    references ACT_RU_EXECUTION (ID_);
-
-alter table ACT_RU_VARIABLE
-    add constraint ACT_FK_VAR_PROCINST
-    foreign key (PROC_INST_ID_)
-    references ACT_RU_EXECUTION(ID_);
-
-alter table ACT_RU_VARIABLE
-    add constraint ACT_FK_VAR_BYTEARRAY
-    foreign key (BYTEARRAY_ID_)
-    references ACT_GE_BYTEARRAY (ID_);
-
-alter table ACT_RU_JOB
-    add constraint ACT_FK_JOB_EXCEPTION
-    foreign key (EXCEPTION_STACK_ID_)
-    references ACT_GE_BYTEARRAY (ID_);
-
-alter table ACT_RU_EVENT_SUBSCR
-    add constraint ACT_FK_EVENT_EXEC
-    foreign key (EXECUTION_ID_)
-    references ACT_RU_EXECUTION(ID_);
-
-alter table ACT_RU_INCIDENT
-    add constraint ACT_FK_INC_EXE
-    foreign key (EXECUTION_ID_)
-    references ACT_RU_EXECUTION (ID_);
-
-alter table ACT_RU_INCIDENT
-    add constraint ACT_FK_INC_PROCINST
-    foreign key (PROC_INST_ID_)
-    references ACT_RU_EXECUTION (ID_);
-
-alter table ACT_RU_INCIDENT
-    add constraint ACT_FK_INC_PROCDEF
-    foreign key (PROC_DEF_ID_)
-    references ACT_RE_PROCDEF (ID_);
-
-alter table ACT_RU_INCIDENT
-    add constraint ACT_FK_INC_CAUSE
-    foreign key (CAUSE_INCIDENT_ID_)
-    references ACT_RU_INCIDENT (ID_) on delete cascade on update cascade;
-
-alter table ACT_RU_INCIDENT
-    add constraint ACT_FK_INC_RCAUSE
-    foreign key (ROOT_CAUSE_INCIDENT_ID_)
-    references ACT_RU_INCIDENT (ID_) on delete cascade on update cascade;
-
-alter table ACT_RU_EXT_TASK
-    add constraint ACT_FK_EXT_TASK_ERROR_DETAILS
-    foreign key (ERROR_DETAILS_ID_)
-    references ACT_GE_BYTEARRAY (ID_);
-
-create index ACT_IDX_INC_JOB_DEF on ACT_RU_INCIDENT(JOB_DEF_ID_);
-alter table ACT_RU_INCIDENT
-    add constraint ACT_FK_INC_JOB_DEF
-    foreign key (JOB_DEF_ID_)
-    references ACT_RU_JOBDEF (ID_);
-
-alter table ACT_RU_AUTHORIZATION
-    add constraint ACT_UNIQ_AUTH_USER
-    unique (USER_ID_,TYPE_,RESOURCE_TYPE_,RESOURCE_ID_);
-
-alter table ACT_RU_AUTHORIZATION
-    add constraint ACT_UNIQ_AUTH_GROUP
-    unique (GROUP_ID_,TYPE_,RESOURCE_TYPE_,RESOURCE_ID_);
-
-alter table ACT_RU_VARIABLE
-    add constraint ACT_UNIQ_VARIABLE
-    unique (VAR_SCOPE_, NAME_);
-
-alter table ACT_RU_EXT_TASK
-    add constraint ACT_FK_EXT_TASK_EXE
-    foreign key (EXECUTION_ID_)
-    references ACT_RU_EXECUTION (ID_);
-
-create index ACT_IDX_BATCH_SEED_JOB_DEF ON ACT_RU_BATCH(SEED_JOB_DEF_ID_);
-alter table ACT_RU_BATCH
-    add constraint ACT_FK_BATCH_SEED_JOB_DEF
-    foreign key (SEED_JOB_DEF_ID_)
-    references ACT_RU_JOBDEF (ID_);
-
-create index ACT_IDX_BATCH_MONITOR_JOB_DEF ON ACT_RU_BATCH(MONITOR_JOB_DEF_ID_);
-alter table ACT_RU_BATCH
-    add constraint ACT_FK_BATCH_MONITOR_JOB_DEF
-    foreign key (MONITOR_JOB_DEF_ID_)
-    references ACT_RU_JOBDEF (ID_);
-
-create index ACT_IDX_BATCH_JOB_DEF ON ACT_RU_BATCH(BATCH_JOB_DEF_ID_);
-alter table ACT_RU_BATCH
-    add constraint ACT_FK_BATCH_JOB_DEF
-    foreign key (BATCH_JOB_DEF_ID_)
-    references ACT_RU_JOBDEF (ID_);
-
--- indexes for deadlock problems - https://app.camunda.com/jira/browse/CAM-2567 --
-create index ACT_IDX_INC_CAUSEINCID on ACT_RU_INCIDENT(CAUSE_INCIDENT_ID_);
-create index ACT_IDX_INC_EXID on ACT_RU_INCIDENT(EXECUTION_ID_);
-create index ACT_IDX_INC_PROCDEFID on ACT_RU_INCIDENT(PROC_DEF_ID_);
-create index ACT_IDX_INC_PROCINSTID on ACT_RU_INCIDENT(PROC_INST_ID_);
-create index ACT_IDX_INC_ROOTCAUSEINCID on ACT_RU_INCIDENT(ROOT_CAUSE_INCIDENT_ID_);
--- index for deadlock problem - https://app.camunda.com/jira/browse/CAM-4440 --
-create index ACT_IDX_AUTH_RESOURCE_ID on ACT_RU_AUTHORIZATION(RESOURCE_ID_);
--- index to prevent deadlock on fk constraint - https://app.camunda.com/jira/browse/CAM-5440 --
-create index ACT_IDX_EXT_TASK_EXEC on ACT_RU_EXT_TASK(EXECUTION_ID_);
-
--- indexes to improve deployment
-create index ACT_IDX_BYTEARRAY_NAME on ACT_GE_BYTEARRAY(NAME_);
-create index ACT_IDX_DEPLOYMENT_NAME on ACT_RE_DEPLOYMENT(NAME_);
-create index ACT_IDX_DEPLOYMENT_TENANT_ID on ACT_RE_DEPLOYMENT(TENANT_ID_);
-create index ACT_IDX_JOBDEF_PROC_DEF_ID ON ACT_RU_JOBDEF(PROC_DEF_ID_);
-create index ACT_IDX_JOB_HANDLER_TYPE ON ACT_RU_JOB(HANDLER_TYPE_);
-create index ACT_IDX_EVENT_SUBSCR_EVT_NAME ON ACT_RU_EVENT_SUBSCR(EVENT_NAME_);
-create index ACT_IDX_PROCDEF_DEPLOYMENT_ID ON ACT_RE_PROCDEF(DEPLOYMENT_ID_);
-create index ACT_IDX_PROCDEF_TENANT_ID ON ACT_RE_PROCDEF(TENANT_ID_);
-create index ACT_IDX_PROCDEF_VER_TAG ON ACT_RE_PROCDEF(VERSION_TAG_);
--- create case definition table --
-create table ACT_RE_CASE_DEF (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    CATEGORY_ varchar(255),
-    NAME_ varchar(255),
-    KEY_ varchar(255) not null,
-    VERSION_ integer not null,
-    DEPLOYMENT_ID_ varchar(64),
-    RESOURCE_NAME_ varchar(4000),
-    DGRM_RESOURCE_NAME_ varchar(4000),
-    TENANT_ID_ varchar(64),
-    HISTORY_TTL_ integer,
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
--- create case execution table --
-create table ACT_RU_CASE_EXECUTION (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    CASE_INST_ID_ varchar(64),
-    SUPER_CASE_EXEC_ varchar(64),
-    SUPER_EXEC_ varchar(64),
-    BUSINESS_KEY_ varchar(255),
-    PARENT_ID_ varchar(64),
-    CASE_DEF_ID_ varchar(64),
-    ACT_ID_ varchar(255),
-    PREV_STATE_ integer,
-    CURRENT_STATE_ integer,
-    REQUIRED_ boolean,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
--- create case sentry part table --
-
-create table ACT_RU_CASE_SENTRY_PART (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    CASE_INST_ID_ varchar(64),
-    CASE_EXEC_ID_ varchar(64),
-    SENTRY_ID_ varchar(255),
-    TYPE_ varchar(255),
-    SOURCE_CASE_EXEC_ID_ varchar(64),
-    STANDARD_EVENT_ varchar(255),
-    SOURCE_ varchar(255),
-    VARIABLE_EVENT_ varchar(255),
-    VARIABLE_NAME_ varchar(255),
-    SATISFIED_ boolean,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
--- create index on business key --
-create index ACT_IDX_CASE_EXEC_BUSKEY on ACT_RU_CASE_EXECUTION(BUSINESS_KEY_);
-
--- create foreign key constraints on ACT_RU_CASE_EXECUTION --
-alter table ACT_RU_CASE_EXECUTION
-    add constraint ACT_FK_CASE_EXE_CASE_INST
-    foreign key (CASE_INST_ID_)
-    references ACT_RU_CASE_EXECUTION(ID_) on delete cascade on update cascade;
-
-alter table ACT_RU_CASE_EXECUTION
-    add constraint ACT_FK_CASE_EXE_PARENT
-    foreign key (PARENT_ID_)
-    references ACT_RU_CASE_EXECUTION(ID_);
-
-alter table ACT_RU_CASE_EXECUTION
-    add constraint ACT_FK_CASE_EXE_CASE_DEF
-    foreign key (CASE_DEF_ID_)
-    references ACT_RE_CASE_DEF(ID_);
-
--- create foreign key constraints on ACT_RU_VARIABLE --
-alter table ACT_RU_VARIABLE
-    add constraint ACT_FK_VAR_CASE_EXE
-    foreign key (CASE_EXECUTION_ID_)
-    references ACT_RU_CASE_EXECUTION(ID_);
-
-alter table ACT_RU_VARIABLE
-    add constraint ACT_FK_VAR_CASE_INST
-    foreign key (CASE_INST_ID_)
-    references ACT_RU_CASE_EXECUTION(ID_);
-
--- create foreign key constraints on ACT_RU_TASK --
-alter table ACT_RU_TASK
-    add constraint ACT_FK_TASK_CASE_EXE
-    foreign key (CASE_EXECUTION_ID_)
-    references ACT_RU_CASE_EXECUTION(ID_);
-
-alter table ACT_RU_TASK
-  add constraint ACT_FK_TASK_CASE_DEF
-  foreign key (CASE_DEF_ID_)
-  references ACT_RE_CASE_DEF(ID_);
-
--- create foreign key constraints on ACT_RU_CASE_SENTRY_PART --
-alter table ACT_RU_CASE_SENTRY_PART
-    add constraint ACT_FK_CASE_SENTRY_CASE_INST
-    foreign key (CASE_INST_ID_)
-    references ACT_RU_CASE_EXECUTION(ID_);
-
-alter table ACT_RU_CASE_SENTRY_PART
-    add constraint ACT_FK_CASE_SENTRY_CASE_EXEC
-    foreign key (CASE_EXEC_ID_)
-    references ACT_RU_CASE_EXECUTION(ID_);
-
-create index ACT_IDX_CASE_DEF_TENANT_ID on ACT_RE_CASE_DEF(TENANT_ID_);
-create index ACT_IDX_CASE_EXEC_TENANT_ID on ACT_RU_CASE_EXECUTION(TENANT_ID_);
--- create decision definition table --
-create table ACT_RE_DECISION_DEF (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    CATEGORY_ varchar(255),
-    NAME_ varchar(255),
-    KEY_ varchar(255) not null,
-    VERSION_ integer not null,
-    DEPLOYMENT_ID_ varchar(64),
-    RESOURCE_NAME_ varchar(4000),
-    DGRM_RESOURCE_NAME_ varchar(4000),
-    DEC_REQ_ID_ varchar(64),
-    DEC_REQ_KEY_ varchar(255),
-    TENANT_ID_ varchar(64),
-    HISTORY_TTL_ integer,
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
--- create decision requirements definition table --
-create table ACT_RE_DECISION_REQ_DEF (
-    ID_ varchar(64) NOT NULL,
-    REV_ integer,
-    CATEGORY_ varchar(255),
-    NAME_ varchar(255),
-    KEY_ varchar(255) NOT NULL,
-    VERSION_ integer NOT NULL,
-    DEPLOYMENT_ID_ varchar(64),
-    RESOURCE_NAME_ varchar(4000),
-    DGRM_RESOURCE_NAME_ varchar(4000),
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-alter table ACT_RE_DECISION_DEF
-    add constraint ACT_FK_DEC_REQ
-    foreign key (DEC_REQ_ID_)
-    references ACT_RE_DECISION_REQ_DEF(ID_);
-
-create index ACT_IDX_DEC_DEF_TENANT_ID on ACT_RE_DECISION_DEF(TENANT_ID_);
-create index ACT_IDX_DEC_DEF_REQ_ID on ACT_RE_DECISION_DEF(DEC_REQ_ID_);
-create index ACT_IDX_DEC_REQ_DEF_TENANT_ID on ACT_RE_DECISION_REQ_DEF(TENANT_ID_);
-create table ACT_HI_PROCINST (
-    ID_ varchar(64) not null,
-    PROC_INST_ID_ varchar(64) not null,
-    BUSINESS_KEY_ varchar(255),
-    PROC_DEF_KEY_ varchar(255),
-    PROC_DEF_ID_ varchar(64) not null,
-    START_TIME_ datetime(3) not null,
-    END_TIME_ datetime(3),
-    DURATION_ bigint,
-    START_USER_ID_ varchar(255),
-    START_ACT_ID_ varchar(255),
-    END_ACT_ID_ varchar(255),
-    SUPER_PROCESS_INSTANCE_ID_ varchar(64),
-    SUPER_CASE_INSTANCE_ID_ varchar(64),
-    CASE_INST_ID_ varchar(64),
-    DELETE_REASON_ varchar(4000),
-    TENANT_ID_ varchar(64),
-    STATE_ varchar(255),
-    primary key (ID_),
-    unique (PROC_INST_ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_ACTINST (
-    ID_ varchar(64) not null,
-    PARENT_ACT_INST_ID_ varchar(64),
-    PROC_DEF_KEY_ varchar(255),
-    PROC_DEF_ID_ varchar(64) not null,
-    PROC_INST_ID_ varchar(64) not null,
-    EXECUTION_ID_ varchar(64) not null,
-    ACT_ID_ varchar(255) not null,
-    TASK_ID_ varchar(64),
-    CALL_PROC_INST_ID_ varchar(64),
-    CALL_CASE_INST_ID_ varchar(64),
-    ACT_NAME_ varchar(255),
-    ACT_TYPE_ varchar(255) not null,
-    ASSIGNEE_ varchar(64),
-    START_TIME_ datetime(3) not null,
-    END_TIME_ datetime(3),
-    DURATION_ bigint,
-    ACT_INST_STATE_ integer,
-    SEQUENCE_COUNTER_ bigint,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_TASKINST (
-    ID_ varchar(64) not null,
-    TASK_DEF_KEY_ varchar(255),
-    PROC_DEF_KEY_ varchar(255),
-    PROC_DEF_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    EXECUTION_ID_ varchar(64),
-    CASE_DEF_KEY_ varchar(255),
-    CASE_DEF_ID_ varchar(64),
-    CASE_INST_ID_ varchar(64),
-    CASE_EXECUTION_ID_ varchar(64),
-    ACT_INST_ID_ varchar(64),
-    NAME_ varchar(255),
-    PARENT_TASK_ID_ varchar(64),
-    DESCRIPTION_ varchar(4000),
-    OWNER_ varchar(255),
-    ASSIGNEE_ varchar(255),
-    START_TIME_ datetime(3) not null,
-    END_TIME_ datetime(3),
-    DURATION_ bigint,
-    DELETE_REASON_ varchar(4000),
-    PRIORITY_ integer,
-    DUE_DATE_ datetime(3),
-    FOLLOW_UP_DATE_ datetime(3),
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_VARINST (
-    ID_ varchar(64) not null,
-    PROC_DEF_KEY_ varchar(255),
-    PROC_DEF_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    EXECUTION_ID_ varchar(64),
-    ACT_INST_ID_ varchar(64),
-    CASE_DEF_KEY_ varchar(255),
-    CASE_DEF_ID_ varchar(64),
-    CASE_INST_ID_ varchar(64),
-    CASE_EXECUTION_ID_ varchar(64),
-    TASK_ID_ varchar(64),
-    NAME_ varchar(255) not null,
-    VAR_TYPE_ varchar(100),
-    REV_ integer,
-    BYTEARRAY_ID_ varchar(64),
-    DOUBLE_ double,
-    LONG_ bigint,
-    TEXT_ LONGBLOB NULL,
-    TEXT2_ LONGBLOB NULL,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_DETAIL (
-    ID_ varchar(64) not null,
-    TYPE_ varchar(255) not null,
-    PROC_DEF_KEY_ varchar(255),
-    PROC_DEF_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    EXECUTION_ID_ varchar(64),
-    CASE_DEF_KEY_ varchar(255),
-    CASE_DEF_ID_ varchar(64),
-    CASE_INST_ID_ varchar(64),
-    CASE_EXECUTION_ID_ varchar(64),
-    TASK_ID_ varchar(64),
-    ACT_INST_ID_ varchar(64),
-    VAR_INST_ID_ varchar(64),
-    NAME_ varchar(255) not null,
-    VAR_TYPE_ varchar(255),
-    REV_ integer,
-    TIME_ datetime(3) not null,
-    BYTEARRAY_ID_ varchar(64),
-    DOUBLE_ double,
-    LONG_ bigint,
-    TEXT_ LONGBLOB NULL,
-    TEXT2_ LONGBLOB NULL,
-    SEQUENCE_COUNTER_ bigint,
-    TENANT_ID_ varchar(64),
-    OPERATION_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_IDENTITYLINK (
-    ID_ varchar(64) not null,
-    TIMESTAMP_ timestamp(3) not null,
-    TYPE_ varchar(255),
-    USER_ID_ varchar(255),
-    GROUP_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    OPERATION_TYPE_ varchar(64),
-    ASSIGNER_ID_ varchar(64),
-    PROC_DEF_KEY_ varchar(255),
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_COMMENT (
-    ID_ varchar(64) not null,
-    TYPE_ varchar(255),
-    TIME_ datetime(3) not null,
-    USER_ID_ varchar(255),
-    TASK_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    ACTION_ varchar(255),
-    MESSAGE_ varchar(4000),
-    FULL_MSG_ LONGBLOB,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_ATTACHMENT (
-    ID_ varchar(64) not null,
-    REV_ integer,
-    USER_ID_ varchar(255),
-    NAME_ varchar(255),
-    DESCRIPTION_ varchar(4000),
-    TYPE_ varchar(255),
-    TASK_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    URL_ varchar(4000),
-    CONTENT_ID_ varchar(64),
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_OP_LOG (
-    ID_ varchar(64) not null,
-    DEPLOYMENT_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    PROC_DEF_KEY_ varchar(255),
-    PROC_INST_ID_ varchar(64),
-    EXECUTION_ID_ varchar(64),
-    CASE_DEF_ID_ varchar(64),
-    CASE_INST_ID_ varchar(64),
-    CASE_EXECUTION_ID_ varchar(64),
-    TASK_ID_ varchar(64),
-    JOB_ID_ varchar(64),
-    JOB_DEF_ID_ varchar(64),
-    BATCH_ID_ varchar(64),
-    USER_ID_ varchar(255),
-    TIMESTAMP_ timestamp(3) not null,
-    OPERATION_TYPE_ varchar(64),
-    OPERATION_ID_ varchar(64),
-    ENTITY_TYPE_ varchar(30),
-    PROPERTY_ varchar(64),
-    ORG_VALUE_ varchar(4000),
-    NEW_VALUE_ varchar(4000),
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_INCIDENT (
-  ID_ varchar(64) not null,
-  PROC_DEF_KEY_ varchar(255),
-  PROC_DEF_ID_ varchar(64),
-  PROC_INST_ID_ varchar(64),
-  EXECUTION_ID_ varchar(64),
-  CREATE_TIME_ timestamp(3) not null,
-  END_TIME_ timestamp(3) null,
-  INCIDENT_MSG_ varchar(4000),
-  INCIDENT_TYPE_ varchar(255) not null,
-  ACTIVITY_ID_ varchar(255),
-  CAUSE_INCIDENT_ID_ varchar(64),
-  ROOT_CAUSE_INCIDENT_ID_ varchar(64),
-  CONFIGURATION_ varchar(255),
-  INCIDENT_STATE_ integer,
-  TENANT_ID_ varchar(64),
-  JOB_DEF_ID_ varchar(64),
-  primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_JOB_LOG (
-    ID_ varchar(64) not null,
-    TIMESTAMP_ timestamp(3) not null,
-    JOB_ID_ varchar(64) not null,
-    JOB_DUEDATE_ timestamp(3) NULL,
-    JOB_RETRIES_ integer,
-    JOB_PRIORITY_ bigint NOT NULL DEFAULT 0,
-    JOB_EXCEPTION_MSG_ varchar(4000),
-    JOB_EXCEPTION_STACK_ID_ varchar(64),
-    JOB_STATE_ integer,
-    JOB_DEF_ID_ varchar(64),
-    JOB_DEF_TYPE_ varchar(255),
-    JOB_DEF_CONFIGURATION_ varchar(255),
-    ACT_ID_ varchar(255),
-    EXECUTION_ID_ varchar(64),
-    PROCESS_INSTANCE_ID_ varchar(64),
-    PROCESS_DEF_ID_ varchar(64),
-    PROCESS_DEF_KEY_ varchar(255),
-    DEPLOYMENT_ID_ varchar(64),
-    SEQUENCE_COUNTER_ bigint,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_BATCH (
-    ID_ varchar(64) not null,
-    TYPE_ varchar(255),
-    TOTAL_JOBS_ integer,
-    JOBS_PER_SEED_ integer,
-    INVOCATIONS_PER_JOB_ integer,
-    SEED_JOB_DEF_ID_ varchar(64),
-    MONITOR_JOB_DEF_ID_ varchar(64),
-    BATCH_JOB_DEF_ID_ varchar(64),
-    TENANT_ID_  varchar(64),
-    START_TIME_ datetime(3) not null,
-    END_TIME_ datetime(3),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_EXT_TASK_LOG (
-    ID_ varchar(64) not null,
-    TIMESTAMP_ timestamp(3) not null,
-    EXT_TASK_ID_ varchar(64) not null,
-    RETRIES_ integer,
-    TOPIC_NAME_ varchar(255),
-    WORKER_ID_ varchar(255),
-    PRIORITY_ bigint NOT NULL DEFAULT 0,
-    ERROR_MSG_ varchar(4000),
-    ERROR_DETAILS_ID_ varchar(64),
-    ACT_ID_ varchar(255),
-    ACT_INST_ID_ varchar(64),
-    EXECUTION_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    PROC_DEF_ID_ varchar(64),
-    PROC_DEF_KEY_ varchar(255),
-    TENANT_ID_ varchar(64),
-    STATE_ integer,
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create index ACT_IDX_HI_PRO_INST_END on ACT_HI_PROCINST(END_TIME_);
-create index ACT_IDX_HI_PRO_I_BUSKEY on ACT_HI_PROCINST(BUSINESS_KEY_);
-create index ACT_IDX_HI_PRO_INST_TENANT_ID on ACT_HI_PROCINST(TENANT_ID_);
-create index ACT_IDX_HI_PRO_INST_PROC_DEF_KEY on ACT_HI_PROCINST(PROC_DEF_KEY_);
-
-create index ACT_IDX_HI_ACT_INST_START on ACT_HI_ACTINST(START_TIME_);
-create index ACT_IDX_HI_ACT_INST_END on ACT_HI_ACTINST(END_TIME_);
-create index ACT_IDX_HI_ACT_INST_PROCINST on ACT_HI_ACTINST(PROC_INST_ID_, ACT_ID_);
-create index ACT_IDX_HI_ACT_INST_COMP on ACT_HI_ACTINST(EXECUTION_ID_, ACT_ID_, END_TIME_, ID_);
-create index ACT_IDX_HI_ACT_INST_STATS on ACT_HI_ACTINST(PROC_DEF_ID_, ACT_ID_, END_TIME_, ACT_INST_STATE_);
-create index ACT_IDX_HI_ACT_INST_TENANT_ID on ACT_HI_ACTINST(TENANT_ID_);
-create index ACT_IDX_HI_ACT_INST_PROC_DEF_KEY on ACT_HI_ACTINST(PROC_DEF_KEY_);
-
-create index ACT_IDX_HI_TASK_INST_TENANT_ID on ACT_HI_TASKINST(TENANT_ID_);
-create index ACT_IDX_HI_TASK_INST_PROC_DEF_KEY on ACT_HI_TASKINST(PROC_DEF_KEY_);
-
-create index ACT_IDX_HI_DETAIL_PROC_INST on ACT_HI_DETAIL(PROC_INST_ID_);
-create index ACT_IDX_HI_DETAIL_ACT_INST on ACT_HI_DETAIL(ACT_INST_ID_);
-create index ACT_IDX_HI_DETAIL_CASE_INST on ACT_HI_DETAIL(CASE_INST_ID_);
-create index ACT_IDX_HI_DETAIL_CASE_EXEC on ACT_HI_DETAIL(CASE_EXECUTION_ID_);
-create index ACT_IDX_HI_DETAIL_TIME on ACT_HI_DETAIL(TIME_);
-create index ACT_IDX_HI_DETAIL_NAME on ACT_HI_DETAIL(NAME_);
-create index ACT_IDX_HI_DETAIL_TASK_ID on ACT_HI_DETAIL(TASK_ID_);
-create index ACT_IDX_HI_DETAIL_TENANT_ID on ACT_HI_DETAIL(TENANT_ID_);
-create index ACT_IDX_HI_DETAIL_PROC_DEF_KEY on ACT_HI_DETAIL(PROC_DEF_KEY_);
-
-create index ACT_IDX_HI_IDENT_LNK_USER on ACT_HI_IDENTITYLINK(USER_ID_);
-create index ACT_IDX_HI_IDENT_LNK_GROUP on ACT_HI_IDENTITYLINK(GROUP_ID_);
-create index ACT_IDX_HI_IDENT_LNK_TENANT_ID on ACT_HI_IDENTITYLINK(TENANT_ID_);
-create index ACT_IDX_HI_IDENT_LNK_PROC_DEF_KEY on ACT_HI_IDENTITYLINK(PROC_DEF_KEY_);
-
-create index ACT_IDX_HI_PROCVAR_PROC_INST on ACT_HI_VARINST(PROC_INST_ID_);
-create index ACT_IDX_HI_PROCVAR_NAME_TYPE on ACT_HI_VARINST(NAME_, VAR_TYPE_);
-create index ACT_IDX_HI_CASEVAR_CASE_INST on ACT_HI_VARINST(CASE_INST_ID_);
-create index ACT_IDX_HI_VAR_INST_TENANT_ID on ACT_HI_VARINST(TENANT_ID_);
-create index ACT_IDX_HI_VAR_INST_PROC_DEF_KEY on ACT_HI_VARINST(PROC_DEF_KEY_);
-
-create index ACT_IDX_HI_INCIDENT_TENANT_ID on ACT_HI_INCIDENT(TENANT_ID_);
-create index ACT_IDX_HI_INCIDENT_PROC_DEF_KEY on ACT_HI_INCIDENT(PROC_DEF_KEY_);
-
-create index ACT_IDX_HI_JOB_LOG_PROCINST on ACT_HI_JOB_LOG(PROCESS_INSTANCE_ID_);
-create index ACT_IDX_HI_JOB_LOG_PROCDEF on ACT_HI_JOB_LOG(PROCESS_DEF_ID_);
-create index ACT_IDX_HI_JOB_LOG_TENANT_ID on ACT_HI_JOB_LOG(TENANT_ID_);
-create index ACT_IDX_HI_JOB_LOG_JOB_DEF_ID on ACT_HI_JOB_LOG(JOB_DEF_ID_);
-create index ACT_IDX_HI_JOB_LOG_PROC_DEF_KEY on ACT_HI_JOB_LOG(PROCESS_DEF_KEY_);
-
-create index ACT_HI_EXT_TASK_LOG_PROCINST on ACT_HI_EXT_TASK_LOG(PROC_INST_ID_);
-create index ACT_HI_EXT_TASK_LOG_PROCDEF on ACT_HI_EXT_TASK_LOG(PROC_DEF_ID_);
-create index ACT_HI_EXT_TASK_LOG_PROC_DEF_KEY on ACT_HI_EXT_TASK_LOG(PROC_DEF_KEY_);
-create index ACT_HI_EXT_TASK_LOG_TENANT_ID on ACT_HI_EXT_TASK_LOG(TENANT_ID_);
-
-create index ACT_IDX_HI_OP_LOG_PROCINST on ACT_HI_OP_LOG(PROC_INST_ID_);
-create index ACT_IDX_HI_OP_LOG_PROCDEF on ACT_HI_OP_LOG(PROC_DEF_ID_);
-create table ACT_HI_CASEINST (
-    ID_ varchar(64) not null,
-    CASE_INST_ID_ varchar(64) not null,
-    BUSINESS_KEY_ varchar(255),
-    CASE_DEF_ID_ varchar(64) not null,
-    CREATE_TIME_ datetime(3) not null,
-    CLOSE_TIME_ datetime(3),
-    DURATION_ bigint,
-    STATE_ integer,
-    CREATE_USER_ID_ varchar(255),
-    SUPER_CASE_INSTANCE_ID_ varchar(64),
-    SUPER_PROCESS_INSTANCE_ID_ varchar(64),
-    TENANT_ID_ varchar(64),
-    primary key (ID_),
-    unique (CASE_INST_ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_HI_CASEACTINST (
-    ID_ varchar(64) not null,
-    PARENT_ACT_INST_ID_ varchar(64),
-    CASE_DEF_ID_ varchar(64) not null,
-    CASE_INST_ID_ varchar(64) not null,
-    CASE_ACT_ID_ varchar(255) not null,
-    TASK_ID_ varchar(64),
-    CALL_PROC_INST_ID_ varchar(64),
-    CALL_CASE_INST_ID_ varchar(64),
-    CASE_ACT_NAME_ varchar(255),
-    CASE_ACT_TYPE_ varchar(255),
-    CREATE_TIME_ datetime(3) not null,
-    END_TIME_ datetime(3),
-    DURATION_ bigint,
-    STATE_ integer,
-    REQUIRED_ boolean,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create index ACT_IDX_HI_CAS_I_CLOSE on ACT_HI_CASEINST(CLOSE_TIME_);
-create index ACT_IDX_HI_CAS_I_BUSKEY on ACT_HI_CASEINST(BUSINESS_KEY_);
-create index ACT_IDX_HI_CAS_I_TENANT_ID on ACT_HI_CASEINST(TENANT_ID_);
-create index ACT_IDX_HI_CAS_A_I_CREATE on ACT_HI_CASEACTINST(CREATE_TIME_);
-create index ACT_IDX_HI_CAS_A_I_END on ACT_HI_CASEACTINST(END_TIME_);
-create index ACT_IDX_HI_CAS_A_I_COMP on ACT_HI_CASEACTINST(CASE_ACT_ID_, END_TIME_, ID_);
-create index ACT_IDX_HI_CAS_A_I_CASEINST on ACT_HI_CASEACTINST(CASE_INST_ID_, CASE_ACT_ID_);
-create index ACT_IDX_HI_CAS_A_I_TENANT_ID on ACT_HI_CASEACTINST(TENANT_ID_);
--- create history decision instance table --
-create table ACT_HI_DECINST (
-    ID_ varchar(64) NOT NULL,
-    DEC_DEF_ID_ varchar(64) NOT NULL,
-    DEC_DEF_KEY_ varchar(255) NOT NULL,
-    DEC_DEF_NAME_ varchar(255),
-    PROC_DEF_KEY_ varchar(255),
-    PROC_DEF_ID_ varchar(64),
-    PROC_INST_ID_ varchar(64),
-    CASE_DEF_KEY_ varchar(255),
-    CASE_DEF_ID_ varchar(64),
-    CASE_INST_ID_ varchar(64),
-    ACT_INST_ID_ varchar(64),
-    ACT_ID_ varchar(255),
-    EVAL_TIME_ datetime(3) not null,
-    COLLECT_VALUE_ double,
-    USER_ID_ varchar(255),
-    ROOT_DEC_INST_ID_ varchar(64),
-    DEC_REQ_ID_ varchar(64),
-    DEC_REQ_KEY_ varchar(255),
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
--- create history decision input table --
-create table ACT_HI_DEC_IN (
-    ID_ varchar(64) NOT NULL,
-    DEC_INST_ID_ varchar(64) NOT NULL,
-    CLAUSE_ID_ varchar(64),
-    CLAUSE_NAME_ varchar(255),
-    VAR_TYPE_ varchar(100),
-    BYTEARRAY_ID_ varchar(64),
-    DOUBLE_ double,
-    LONG_ bigint,
-    TEXT_ LONGBLOB NULL,
-    TEXT2_ LONGBLOB NULL,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
--- create history decision output table --
-create table ACT_HI_DEC_OUT (
-    ID_ varchar(64) NOT NULL,
-    DEC_INST_ID_ varchar(64) NOT NULL,
-    CLAUSE_ID_ varchar(64),
-    CLAUSE_NAME_ varchar(255),
-    RULE_ID_ varchar(64),
-    RULE_ORDER_ integer,
-    VAR_NAME_ varchar(255),
-    VAR_TYPE_ varchar(100),
-    BYTEARRAY_ID_ varchar(64),
-    DOUBLE_ double,
-    LONG_ bigint,
-    TEXT_ LONGBLOB NULL,
-    TEXT2_ LONGBLOB NULL,
-    TENANT_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-
-create index ACT_IDX_HI_DEC_INST_ID on ACT_HI_DECINST(DEC_DEF_ID_);
-create index ACT_IDX_HI_DEC_INST_KEY on ACT_HI_DECINST(DEC_DEF_KEY_);
-create index ACT_IDX_HI_DEC_INST_PI on ACT_HI_DECINST(PROC_INST_ID_);
-create index ACT_IDX_HI_DEC_INST_CI on ACT_HI_DECINST(CASE_INST_ID_);
-create index ACT_IDX_HI_DEC_INST_ACT on ACT_HI_DECINST(ACT_ID_);
-create index ACT_IDX_HI_DEC_INST_ACT_INST on ACT_HI_DECINST(ACT_INST_ID_);
-create index ACT_IDX_HI_DEC_INST_TIME on ACT_HI_DECINST(EVAL_TIME_);
-create index ACT_IDX_HI_DEC_INST_TENANT_ID on ACT_HI_DECINST(TENANT_ID_);
-create index ACT_IDX_HI_DEC_INST_ROOT_ID on ACT_HI_DECINST(ROOT_DEC_INST_ID_);
-create index ACT_IDX_HI_DEC_INST_REQ_ID on ACT_HI_DECINST(DEC_REQ_ID_);
-create index ACT_IDX_HI_DEC_INST_REQ_KEY on ACT_HI_DECINST(DEC_REQ_KEY_);
-
-
-create index ACT_IDX_HI_DEC_IN_INST on ACT_HI_DEC_IN(DEC_INST_ID_);
-create index ACT_IDX_HI_DEC_IN_CLAUSE on ACT_HI_DEC_IN(DEC_INST_ID_, CLAUSE_ID_);
-
-create index ACT_IDX_HI_DEC_OUT_INST on ACT_HI_DEC_OUT(DEC_INST_ID_);
-create index ACT_IDX_HI_DEC_OUT_RULE on ACT_HI_DEC_OUT(RULE_ORDER_, CLAUSE_ID_);
-
-
--- mariadb identity:
-
-create table ACT_ID_GROUP (
-    ID_ varchar(64),
-    REV_ integer,
-    NAME_ varchar(255),
-    TYPE_ varchar(255),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_ID_MEMBERSHIP (
-    USER_ID_ varchar(64),
-    GROUP_ID_ varchar(64),
-    primary key (USER_ID_, GROUP_ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_ID_USER (
-    ID_ varchar(64),
-    REV_ integer,
-    FIRST_ varchar(255),
-    LAST_ varchar(255),
-    EMAIL_ varchar(255),
-    PWD_ varchar(255),
-    SALT_ varchar(255),
-    PICTURE_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_ID_INFO (
-    ID_ varchar(64),
-    REV_ integer,
-    USER_ID_ varchar(64),
-    TYPE_ varchar(64),
-    KEY_ varchar(255),
-    VALUE_ varchar(255),
-    PASSWORD_ LONGBLOB,
-    PARENT_ID_ varchar(255),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_ID_TENANT (
-    ID_ varchar(64),
-    REV_ integer,
-    NAME_ varchar(255),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-create table ACT_ID_TENANT_MEMBER (
-    ID_ varchar(64) not null,
-    TENANT_ID_ varchar(64) not null,
-    USER_ID_ varchar(64),
-    GROUP_ID_ varchar(64),
-    primary key (ID_)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
-
-alter table ACT_ID_MEMBERSHIP
-    add constraint ACT_FK_MEMB_GROUP
-    foreign key (GROUP_ID_)
-    references ACT_ID_GROUP (ID_);
-
-alter table ACT_ID_MEMBERSHIP
-    add constraint ACT_FK_MEMB_USER
-    foreign key (USER_ID_)
-    references ACT_ID_USER (ID_);
-
-alter table ACT_ID_TENANT_MEMBER
-    add constraint ACT_UNIQ_TENANT_MEMB_USER
-    unique (TENANT_ID_, USER_ID_);
-
-alter table ACT_ID_TENANT_MEMBER
-    add constraint ACT_UNIQ_TENANT_MEMB_GROUP
-    unique (TENANT_ID_, GROUP_ID_);
-
-alter table ACT_ID_TENANT_MEMBER
-    add constraint ACT_FK_TENANT_MEMB
-    foreign key (TENANT_ID_)
-    references ACT_ID_TENANT (ID_);
-
-alter table ACT_ID_TENANT_MEMBER
-    add constraint ACT_FK_TENANT_MEMB_USER
-    foreign key (USER_ID_)
-    references ACT_ID_USER (ID_);
-
-alter table ACT_ID_TENANT_MEMBER
-    add constraint ACT_FK_TENANT_MEMB_GROUP
-    foreign key (GROUP_ID_)
-    references ACT_ID_GROUP (ID_);
-
diff --git a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/camunda/mysql_create_camunda_admin.sql b/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/camunda/mysql_create_camunda_admin.sql
deleted file mode 100644
index 40fda9a..0000000
--- a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/camunda/mysql_create_camunda_admin.sql
+++ /dev/null
@@ -1,40 +0,0 @@
-/* Copyright © 2017 AT&T, Amdocs, Bell Canada
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*       http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-USE camundabpmn;
-
-INSERT INTO `act_id_group` (`ID_`, `REV_`, `NAME_`, `TYPE_`) VALUES ('camunda-admin',1,'camunda BPM Administrators','SYSTEM');
-
-INSERT INTO `act_id_user` (`ID_`, `REV_`, `FIRST_`, `LAST_`, `EMAIL_`, `PWD_`, `SALT_`, `PICTURE_ID_`) VALUES ('admin',1,'admin','user','camundaadmin@onap.org','{SHA-512}n5jUw7fvXM9sZBcrIkLiAOCqiPHutaqEkbg6IQVQdylVP1im8SczBJf4f2xL7cvWwIAZjkcSSQzgFTsdaJSEiA==','ftTn4gNgMcq07wdSD0lEJQ==',NULL);
-
-INSERT INTO `act_id_membership` (`USER_ID_`, `GROUP_ID_`) VALUES ('admin','camunda-admin');
-
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49b0e028-a3c6-11e7-b0ec-0242ac120003',1,1,NULL,'admin',1,'admin',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49b525e9-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,2,'camunda-admin',2);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49b8814a-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,0,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49baa42b-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,1,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49bd8a5c-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,2,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49bfd44d-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,3,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49c1f72e-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,4,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49c41a0f-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,5,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49c77570-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,6,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49ca5ba1-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,7,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49cca592-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,8,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49ceef83-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,9,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49d11264-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,10,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49d38365-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,11,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49d5a646-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,12,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49d83e57-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,13,'*',2147483647);
-INSERT INTO `act_ru_authorization` (`ID_`, `REV_`, `TYPE_`, `GROUP_ID_`, `USER_ID_`, `RESOURCE_TYPE_`, `RESOURCE_ID_`, `PERMS_`) VALUES ('49da3a28-a3c6-11e7-b0ec-0242ac120003',1,1,'camunda-admin',NULL,14,'*',2147483647);
diff --git a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/main-schemas/MySQL-Catalog-schema.sql b/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/main-schemas/MySQL-Catalog-schema.sql
deleted file mode 100644
index d05bc49..0000000
--- a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/main-schemas/MySQL-Catalog-schema.sql
+++ /dev/null
@@ -1,477 +0,0 @@
-/* Copyright © 2017 AT&T, Amdocs, Bell Canada
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*       http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-
-    alter table HEAT_TEMPLATE_PARAMS 
-        drop 
-        foreign key FK_p3ol1xcvp831glqohrlu6o07o;
-
-    alter table MODEL_RECIPE 
-        drop 
-        foreign key FK_c23r0puyqug6n44jg39dutm1c;
-
-    alter table SERVICE 
-        drop 
-        foreign key FK_l3qy594u2xr1tfpmma3uigsna;
-
-    alter table SERVICE_RECIPE 
-        drop 
-        foreign key FK_i3r1b8j6e7dg9hkp49evnnm5y;
-
-    alter table SERVICE_TO_RESOURCE_CUSTOMIZATIONS 
-        drop 
-        foreign key FK_kiddaay6cfe0aob1f1jaio1bb;
-
-    alter table VF_MODULE 
-        drop 
-        foreign key FK_12jptc9it7gs3pru08skobxxc;
-
-    alter table VNF_RESOURCE_CUSTOMIZATION 
-        drop 
-        foreign key FK_iff1ayhb1hrp5jhea3vvikuni;
-
-    drop table if exists ALLOTTED_RESOURCE;
-
-    drop table if exists ALLOTTED_RESOURCE_CUSTOMIZATION;
-
-    drop table if exists HEAT_ENVIRONMENT;
-
-    drop table if exists HEAT_FILES;
-
-    drop table if exists HEAT_NESTED_TEMPLATE;
-
-    drop table if exists HEAT_TEMPLATE;
-
-    drop table if exists HEAT_TEMPLATE_PARAMS;
-
-    drop table if exists MODEL;
-
-    drop table if exists MODEL_RECIPE;
-
-    drop table if exists NETWORK_RECIPE;
-
-    drop table if exists NETWORK_RESOURCE;
-
-    drop table if exists NETWORK_RESOURCE_CUSTOMIZATION;
-
-    drop table if exists SERVICE;
-
-    drop table if exists SERVICE_RECIPE;
-
-    drop table if exists SERVICE_TO_ALLOTTED_RESOURCES;
-
-    drop table if exists SERVICE_TO_NETWORKS;
-
-    drop table if exists SERVICE_TO_RESOURCE_CUSTOMIZATIONS;
-
-    drop table if exists TEMP_NETWORK_HEAT_TEMPLATE_LOOKUP;
-
-    drop table if exists TOSCA_CSAR;
-
-    drop table if exists VF_MODULE;
-
-    drop table if exists VF_MODULE_CUSTOMIZATION;
-
-    drop table if exists VF_MODULE_TO_HEAT_FILES;
-
-    drop table if exists VNF_COMPONENTS;
-
-    drop table if exists VNF_COMPONENTS_RECIPE;
-
-    drop table if exists VNF_RECIPE;
-
-    drop table if exists VNF_RESOURCE;
-
-    drop table if exists VNF_RESOURCE_CUSTOMIZATION;
-
-    drop table if exists VNF_RES_CUSTOM_TO_VF_MODULE_CUSTOM;
-
-    create table ALLOTTED_RESOURCE (
-        MODEL_UUID varchar(255) not null,
-        MODEL_INVARIANT_UUID varchar(255),
-        MODEL_VERSION varchar(255),
-        MODEL_NAME varchar(255),
-        TOSCA_NODE_TYPE varchar(255),
-        SUBCATEGORY varchar(255),
-        DESCRIPTION varchar(255),
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (MODEL_UUID)
-    );
-
-    create table ALLOTTED_RESOURCE_CUSTOMIZATION (
-        MODEL_CUSTOMIZATION_UUID varchar(200) not null,
-        MODEL_INSTANCE_NAME varchar(255),
-        AR_MODEL_UUID varchar(255),
-        PROVIDING_SERVICE_MODEL_INVARIANT_UUID varchar(255),
-        TARGET_NETWORK_ROLE varchar(255),
-        NF_FUNCTION varchar(255),
-        NF_TYPE varchar(255),
-        NF_ROLE varchar(255),
-        NF_NAMING_CODE varchar(255),
-        MIN_INSTANCES integer,
-        MAX_INSTANCES integer,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (MODEL_CUSTOMIZATION_UUID)
-    );
-
-    create table HEAT_ENVIRONMENT (
-        ARTIFACT_UUID varchar(200) not null,
-        NAME varchar(100) not null,
-        VERSION varchar(20) not null,
-        DESCRIPTION varchar(1200),
-        BODY longtext not null,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        ARTIFACT_CHECKSUM varchar(200) default 'MANUAL RECORD',
-        primary key (ARTIFACT_UUID)
-    );
-
-    create table HEAT_FILES (
-        ARTIFACT_UUID varchar(255) not null,
-        DESCRIPTION varchar(255),
-        NAME varchar(255),
-        VERSION varchar(255),
-        BODY longtext,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        ARTIFACT_CHECKSUM varchar(255),
-        primary key (ARTIFACT_UUID)
-    );
-
-    create table HEAT_NESTED_TEMPLATE (
-        PARENT_HEAT_TEMPLATE_UUID varchar(200) not null,
-        CHILD_HEAT_TEMPLATE_UUID varchar(200) not null,
-        PROVIDER_RESOURCE_FILE varchar(100),
-        primary key (PARENT_HEAT_TEMPLATE_UUID, CHILD_HEAT_TEMPLATE_UUID)
-    );
-
-    create table HEAT_TEMPLATE (
-        ARTIFACT_UUID varchar(200) not null,
-        NAME varchar(200) not null,
-        VERSION varchar(20) not null,
-        BODY longtext not null,
-        TIMEOUT_MINUTES integer,
-        DESCRIPTION varchar(1200),
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        ARTIFACT_CHECKSUM varchar(200) default 'MANUAL RECORD' not null,
-        primary key (ARTIFACT_UUID)
-    );
-
-    create table HEAT_TEMPLATE_PARAMS (
-        HEAT_TEMPLATE_ARTIFACT_UUID varchar(255) not null,
-        PARAM_NAME varchar(255) not null,
-        IS_REQUIRED bit not null,
-        PARAM_TYPE varchar(20),
-        PARAM_ALIAS varchar(45),
-        primary key (HEAT_TEMPLATE_ARTIFACT_UUID, PARAM_NAME)
-    );
-
-    create table MODEL (
-        id integer not null auto_increment,
-        MODEL_TYPE varchar(20) not null,
-        MODEL_VERSION_ID varchar(40) not null,
-        MODEL_INVARIANT_ID varchar(40),
-        MODEL_NAME varchar(40) not null,
-        MODEL_VERSION varchar(20),
-        MODEL_CUSTOMIZATION_ID varchar(40),
-        MODEL_CUSTOMIZATION_NAME varchar(40),
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (id)
-    );
-
-    create table MODEL_RECIPE (
-        id integer not null auto_increment,
-        MODEL_ID integer not null,
-        ACTION varchar(20) not null,
-        SCHEMA_VERSION varchar(20),
-        DESCRIPTION varchar(1200),
-        ORCHESTRATION_URI varchar(256) not null,
-        MODEL_PARAM_XSD varchar(2048),
-        RECIPE_TIMEOUT integer,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (id)
-    );
-
-    create table NETWORK_RECIPE (
-        id integer not null auto_increment,
-        MODEL_NAME varchar(20) not null,
-        ACTION varchar(20) not null,
-        VERSION_STR varchar(20) not null,
-        SERVICE_TYPE varchar(45),
-        DESCRIPTION varchar(1200),
-        ORCHESTRATION_URI varchar(256) not null,
-        NETWORK_PARAM_XSD varchar(2048),
-        RECIPE_TIMEOUT integer,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (id)
-    );
-
-    create table NETWORK_RESOURCE (
-        MODEL_UUID varchar(200) not null,
-        MODEL_NAME varchar(200) not null,
-        MODEL_INVARIANT_UUID varchar(200),
-        MODEL_VERSION varchar(20),
-        TOSCA_NODE_TYPE varchar(200),
-        NEUTRON_NETWORK_TYPE varchar(20),
-        DESCRIPTION varchar(1200),
-        ORCHESTRATION_MODE varchar(20),
-        HEAT_TEMPLATE_ARTIFACT_UUID varchar(200) not null,
-        AIC_VERSION_MIN varchar(20) default 2.5 not null,
-        AIC_VERSION_MAX varchar(20) default 2.5,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (MODEL_UUID)
-    );
-
-    create table NETWORK_RESOURCE_CUSTOMIZATION (
-        MODEL_CUSTOMIZATION_UUID varchar(200) not null,
-        NETWORK_RESOURCE_MODEL_UUID varchar(200) not null,
-        MODEL_INSTANCE_NAME varchar(255),
-        NETWORK_TECHNOLOGY varchar(255),
-        NETWORK_TYPE varchar(255),
-        NETWORK_SCOPE varchar(255),
-        NETWORK_ROLE varchar(255),
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (MODEL_CUSTOMIZATION_UUID)
-    );
-
-    create table SERVICE (
-        MODEL_UUID varchar(200) not null,
-        MODEL_NAME varchar(200) not null,
-        MODEL_VERSION varchar(20) not null,
-        DESCRIPTION varchar(1200),
-        TOSCA_CSAR_ARTIFACT_UUID varchar(200),
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        MODEL_INVARIANT_UUID varchar(200) default 'MANUAL_RECORD' not null,
-        SERVICE_TYPE varchar(20),
-        SERVICE_ROLE varchar(20),
-        primary key (MODEL_UUID)
-    );
-
-    create table SERVICE_RECIPE (
-        id integer not null auto_increment,
-        SERVICE_MODEL_UUID varchar(200) not null,
-        ACTION varchar(40) not null,
-        ORCHESTRATION_URI varchar(256) not null,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        VERSION_STR varchar(20),
-        DESCRIPTION varchar(1200),
-        SERVICE_PARAM_XSD varchar(2048),
-        RECIPE_TIMEOUT integer,
-        SERVICE_TIMEOUT_INTERIM integer,
-        primary key (id)
-    );
-
-    create table SERVICE_TO_ALLOTTED_RESOURCES (
-        SERVICE_MODEL_UUID varchar(200) not null,
-        AR_MODEL_CUSTOMIZATION_UUID varchar(200) not null,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (SERVICE_MODEL_UUID, AR_MODEL_CUSTOMIZATION_UUID)
-    );
-
-    create table SERVICE_TO_NETWORKS (
-        SERVICE_MODEL_UUID varchar(200) not null,
-        NETWORK_MODEL_CUSTOMIZATION_UUID varchar(200) not null,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (SERVICE_MODEL_UUID, NETWORK_MODEL_CUSTOMIZATION_UUID)
-    );
-
-    create table SERVICE_TO_RESOURCE_CUSTOMIZATIONS (
-        MODEL_TYPE varchar(20) not null,
-        RESOURCE_MODEL_CUSTOMIZATION_UUID varchar(200) not null,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        SERVICE_MODEL_UUID varchar(200) not null,
-        primary key (MODEL_TYPE, RESOURCE_MODEL_CUSTOMIZATION_UUID)
-    );
-
-    create table TEMP_NETWORK_HEAT_TEMPLATE_LOOKUP (
-        NETWORK_RESOURCE_MODEL_NAME varchar(200) not null,
-        HEAT_TEMPLATE_ARTIFACT_UUID varchar(200) not null,
-        AIC_VERSION_MIN varchar(20) not null,
-        AIC_VERSION_MAX varchar(20),
-        primary key (NETWORK_RESOURCE_MODEL_NAME)
-    );
-
-    create table TOSCA_CSAR (
-        ARTIFACT_UUID varchar(200) not null,
-        NAME varchar(200) not null,
-        VERSION varchar(20) not null,
-        ARTIFACT_CHECKSUM varchar(200) not null,
-        URL varchar(200) not null,
-        DESCRIPTION varchar(1200),
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (ARTIFACT_UUID)
-    );
-
-    create table VF_MODULE (
-        MODEL_UUID varchar(200) not null,
-        VNF_RESOURCE_MODEL_UUID varchar(200),
-        MODEL_INVARIANT_UUID varchar(200),
-        MODEL_VERSION varchar(20) not null,
-        MODEL_NAME varchar(200) not null,
-        DESCRIPTION varchar(1200),
-        IS_BASE integer not null,
-        HEAT_TEMPLATE_ARTIFACT_UUID varchar(200) not null,
-        VOL_HEAT_TEMPLATE_ARTIFACT_UUID varchar(200),
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (MODEL_UUID)
-    );
-
-    create table VF_MODULE_CUSTOMIZATION (
-        MODEL_CUSTOMIZATION_UUID varchar(200) not null,
-        VF_MODULE_MODEL_UUID varchar(200) not null,
-        VOL_ENVIRONMENT_ARTIFACT_UUID varchar(200),
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        HEAT_ENVIRONMENT_ARTIFACT_UUID varchar(200),
-        MIN_INSTANCES integer,
-        MAX_INSTANCES integer,
-        INITIAL_COUNT integer,
-        AVAILABILITY_ZONE_COUNT integer,
-        LABEL varchar(200),
-        primary key (MODEL_CUSTOMIZATION_UUID)
-    );
-
-    create table VF_MODULE_TO_HEAT_FILES (
-        VF_MODULE_MODEL_UUID varchar(200) not null,
-        HEAT_FILES_ARTIFACT_UUID varchar(200) not null,
-        primary key (VF_MODULE_MODEL_UUID, HEAT_FILES_ARTIFACT_UUID)
-    );
-
-    create table VNF_COMPONENTS (
-        VNF_ID integer not null,
-        COMPONENT_TYPE varchar(20) not null,
-        HEAT_TEMPLATE_ID integer,
-        HEAT_ENVIRONMENT_ID integer,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (VNF_ID, COMPONENT_TYPE)
-    );
-
-    create table VNF_COMPONENTS_RECIPE (
-        id integer not null auto_increment,
-        VNF_TYPE varchar(200),
-        VF_MODULE_MODEL_UUID varchar(100),
-        VNF_COMPONENT_TYPE varchar(45) not null,
-        ACTION varchar(20) not null,
-        SERVICE_TYPE varchar(45),
-        VERSION varchar(20),
-        DESCRIPTION varchar(1200),
-        ORCHESTRATION_URI varchar(256) not null,
-        VNF_COMPONENT_PARAM_XSD varchar(2048),
-        RECIPE_TIMEOUT integer,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (id)
-    );
-
-    create table VNF_RECIPE (
-        id integer not null auto_increment,
-        VF_MODULE_ID varchar(100),
-        ACTION varchar(20) not null,
-        VERSION_STR varchar(20) not null,
-        VNF_TYPE varchar(200),
-        SERVICE_TYPE varchar(45) default null,
-        DESCRIPTION varchar(1200),
-        ORCHESTRATION_URI varchar(256) not null,
-        VNF_PARAM_XSD varchar(2048),
-        RECIPE_TIMEOUT integer,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (id)
-    );
-
-    create table VNF_RESOURCE (
-        MODEL_UUID varchar(200) not null,
-        MODEL_INVARIANT_UUID varchar(200),
-        MODEL_VERSION varchar(20) not null,
-        MODEL_NAME varchar(200),
-        TOSCA_NODE_TYPE varchar(200),
-        DESCRIPTION varchar(1200),
-        ORCHESTRATION_MODE varchar(20) not null,
-        AIC_VERSION_MIN varchar(20),
-        AIC_VERSION_MAX varchar(20),
-        HEAT_TEMPLATE_ARTIFACT_UUID varchar(200),
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (MODEL_UUID)
-    );
-
-    create table VNF_RESOURCE_CUSTOMIZATION (
-        MODEL_CUSTOMIZATION_UUID varchar(200) not null,
-        MODEL_INSTANCE_NAME varchar(200) not null,
-        MIN_INSTANCES integer,
-        MAX_INSTANCES integer,
-        AVAILABILITY_ZONE_MAX_COUNT integer,
-        NF_FUNCTION varchar(200),
-        NF_TYPE varchar(200),
-        NF_ROLE varchar(200),
-        NF_NAMING_CODE varchar(200),
-        VNF_RESOURCE_MODEL_UUID varchar(200) not null,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (MODEL_CUSTOMIZATION_UUID)
-    );
-
-    create table VNF_RES_CUSTOM_TO_VF_MODULE_CUSTOM (
-        VNF_RESOURCE_CUST_MODEL_CUSTOMIZATION_UUID varchar(200) not null,
-        VF_MODULE_CUST_MODEL_CUSTOMIZATION_UUID varchar(200) not null,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (VNF_RESOURCE_CUST_MODEL_CUSTOMIZATION_UUID, VF_MODULE_CUST_MODEL_CUSTOMIZATION_UUID)
-    );
-
-    alter table MODEL 
-        add constraint UK_rra00f1rk6eyy7g00k9raxh2v  unique (MODEL_TYPE, MODEL_VERSION_ID);
-
-    alter table MODEL_RECIPE 
-        add constraint UK_b4g8j9wtqrkxfycyi3ursk7gb  unique (MODEL_ID, ACTION);
-
-    alter table NETWORK_RECIPE 
-        add constraint UK_pbsa8i44m8p10f9529jdgfuk9  unique (MODEL_NAME, ACTION, VERSION_STR);
-
-    alter table SERVICE_RECIPE 
-        add constraint UK_2lr377dpqnvl5aqlp5dtj2fcp  unique (SERVICE_MODEL_UUID, ACTION);
-
-    alter table VNF_COMPONENTS_RECIPE 
-        add constraint UK_g3je95aaxxiuest25f0qoy2u8  unique (VNF_TYPE, VF_MODULE_MODEL_UUID, VNF_COMPONENT_TYPE, ACTION, SERVICE_TYPE, VERSION);
-
-    alter table VNF_RECIPE 
-        add constraint UK_f3tvqau498vrifq3cr8qnigkr  unique (VF_MODULE_ID, ACTION, VERSION_STR);
-
-    alter table HEAT_TEMPLATE_PARAMS 
-        add constraint FK_p3ol1xcvp831glqohrlu6o07o 
-        foreign key (HEAT_TEMPLATE_ARTIFACT_UUID) 
-        references HEAT_TEMPLATE (ARTIFACT_UUID);
-
-    alter table MODEL_RECIPE 
-        add constraint FK_c23r0puyqug6n44jg39dutm1c 
-        foreign key (MODEL_ID) 
-        references MODEL (id);
-
-    alter table SERVICE 
-        add constraint FK_l3qy594u2xr1tfpmma3uigsna 
-        foreign key (TOSCA_CSAR_ARTIFACT_UUID) 
-        references TOSCA_CSAR (ARTIFACT_UUID);
-
-    alter table SERVICE_RECIPE 
-        add constraint FK_i3r1b8j6e7dg9hkp49evnnm5y 
-        foreign key (SERVICE_MODEL_UUID) 
-        references SERVICE (MODEL_UUID);
-
-    alter table SERVICE_TO_RESOURCE_CUSTOMIZATIONS 
-        add constraint FK_kiddaay6cfe0aob1f1jaio1bb 
-        foreign key (SERVICE_MODEL_UUID) 
-        references SERVICE (MODEL_UUID);
-
-    alter table VF_MODULE 
-        add constraint FK_12jptc9it7gs3pru08skobxxc 
-        foreign key (VNF_RESOURCE_MODEL_UUID) 
-        references VNF_RESOURCE (MODEL_UUID);
-
-    alter table VNF_RESOURCE_CUSTOMIZATION 
-        add constraint FK_iff1ayhb1hrp5jhea3vvikuni 
-        foreign key (VNF_RESOURCE_MODEL_UUID) 
-        references VNF_RESOURCE (MODEL_UUID);
diff --git a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/main-schemas/MySQL-Requests-schema.sql b/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/main-schemas/MySQL-Requests-schema.sql
deleted file mode 100644
index eff696d..0000000
--- a/kubernetes/so/charts/mariadb/resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/main-schemas/MySQL-Requests-schema.sql
+++ /dev/null
@@ -1,99 +0,0 @@
-/* Copyright © 2017 AT&T, Amdocs, Bell Canada
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*       http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-
-    drop table if exists INFRA_ACTIVE_REQUESTS;
-
-    drop table if exists SITE_STATUS;
-
-    create table INFRA_ACTIVE_REQUESTS (
-        REQUEST_ID varchar(45) not null,
-        CLIENT_REQUEST_ID varchar(45),
-        ACTION varchar(45) not null,
-        REQUEST_STATUS varchar(20),
-        STATUS_MESSAGE varchar(2000),
-        PROGRESS bigint,
-        START_TIME datetime,
-        END_TIME datetime,
-        SOURCE varchar(45),
-        VNF_ID varchar(45),
-        VNF_NAME varchar(80),
-        VNF_TYPE varchar(200),
-        SERVICE_TYPE varchar(45),
-        AIC_NODE_CLLI varchar(11),
-        TENANT_ID varchar(45),
-        PROV_STATUS varchar(20),
-        VNF_PARAMS longtext,
-        VNF_OUTPUTS longtext,
-        REQUEST_BODY longtext,
-        RESPONSE_BODY longtext,
-        LAST_MODIFIED_BY varchar(50),
-        MODIFY_TIME datetime,
-        REQUEST_TYPE varchar(20),
-        VOLUME_GROUP_ID varchar(45),
-        VOLUME_GROUP_NAME varchar(45),
-        VF_MODULE_ID varchar(45),
-        VF_MODULE_NAME varchar(200),
-        VF_MODULE_MODEL_NAME varchar(200),
-        AAI_SERVICE_ID varchar(50),
-        AIC_CLOUD_REGION varchar(11),
-        CALLBACK_URL varchar(200),
-        CORRELATOR varchar(80),
-        SERVICE_INSTANCE_ID varchar(45),
-        SERVICE_INSTANCE_NAME varchar(80),
-        REQUEST_SCOPE varchar(20),
-        REQUEST_ACTION varchar(45) not null,
-        NETWORK_ID varchar(45),
-        NETWORK_NAME varchar(80),
-        NETWORK_TYPE varchar(80),
-        REQUESTOR_ID varchar(80),
-        primary key (REQUEST_ID)
-    );
-
-    create table SITE_STATUS (
-        SITE_NAME varchar(255) not null,
-        STATUS bit,
-        CREATION_TIMESTAMP datetime default CURRENT_TIMESTAMP,
-        primary key (SITE_NAME)
-    );
-	create table OPERATION_STATUS (
-        SERVICE_ID varchar(255) not null,
-        OPERATION_ID varchar(255) not null,
-		SERVICE_NAME varchar(255),
-		OPERATION_TYPE varchar(255),
-		USER_ID varchar(255),
-		RESULT varchar(255),
-		OPERATION_CONTENT varchar(255),
-		PROGRESS varchar(255),
-		REASON varchar(255),
-        OPERATE_AT datetime,
-		FINISHED_AT datetime,
-        primary key (SERVICE_ID,OPERATION_ID)
-    );
-	create table RESOURCE_OPERATION_STATUS (
-        SERVICE_ID varchar(255) not null,
-        OPERATION_ID varchar(255) not null,
-        RESOURCE_TEMPLATE_UUID varchar(255) not null,
-		OPER_TYPE varchar(255),
-		RESOURCE_INSTANCE_ID varchar(255),
-		JOB_ID varchar(255),
-		STATUS varchar(255),
-		PROGRESS varchar(255),
-		ERROR_CODE varchar(255) ,
-		STATUS_DESCRIPOTION varchar(255) ,
-        primary key (SERVICE_ID,OPERATION_ID,RESOURCE_TEMPLATE_UUID)
-    );
-    alter table INFRA_ACTIVE_REQUESTS 
-        add constraint UK_bhu6w8p7wvur4pin0gjw2d5ak  unique (CLIENT_REQUEST_ID);
diff --git a/kubernetes/so/charts/mariadb/templates/configmap.yaml b/kubernetes/so/charts/mariadb/templates/configmap.yaml
index c19e54a..3c71619 100644
--- a/kubernetes/so/charts/mariadb/templates/configmap.yaml
+++ b/kubernetes/so/charts/mariadb/templates/configmap.yaml
@@ -18,60 +18,4 @@
   name: confd-configmap
   namespace: {{ include "common.namespace" . }}
 data:
-{{ tpl (.Files.Glob "resources/config/mariadb/conf.d/*").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: docker-entry-initd-configmap
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/config/mariadb/docker-entrypoint-initdb.d/*").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: automated-tests-configmap
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/automated-tests/*").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: bulkload-default-configmap
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/default/*").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: demo-dns-configmap
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-dns/*").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: demo-vfw-configmap
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-vfw/*").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: scripts-camunda-configmap
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/camunda/*").AsConfig . | indent 2 }}
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: main-schemas-configmap
-  namespace: {{ include "common.namespace" . }}
-data:
-{{ tpl (.Files.Glob "resources/config/mariadb/docker-entrypoint-initdb.d/db-sql-scripts/main-schemas/*").AsConfig . | indent 2 }}
+{{ tpl (.Files.Glob "resources/config/mariadb/conf.d/*").AsConfig . | indent 2 }}
\ No newline at end of file
diff --git a/kubernetes/so/charts/mariadb/templates/deployment.yaml b/kubernetes/so/charts/mariadb/templates/deployment.yaml
index 3e263ce..c85fe79 100644
--- a/kubernetes/so/charts/mariadb/templates/deployment.yaml
+++ b/kubernetes/so/charts/mariadb/templates/deployment.yaml
@@ -31,102 +31,80 @@
         release: {{ .Release.Name }}
     spec:
       hostname: mariadb
+      initContainers:
+      - name: {{ include "common.name" . }}-inject-testlab-project
+        command:
+        - /bin/bash
+        - -c
+        - >
+          git clone -b {{ .Values.config.gerritBranch }} --single-branch {{ .Values.config.gerritProject }} /tmp/gerrit;
+          echo "Clone complete. Copying from /tmp/gerrit/volumes/mariadb/docker-entrypoint-initdb.d to /docker-entrypoint-initdb.d";
+          cp -rf /tmp/gerrit/volumes/mariadb/docker-entrypoint-initdb.d/* /docker-entrypoint-initdb.d;
+          echo "Done.";
+        image: "{{ .Values.global.ubuntuInitRepository }}/{{ .Values.ubuntuInitImage }}"
+        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+        volumeMounts:
+        - name: docker-entrypoint-initdb-d
+          mountPath: "/docker-entrypoint-initdb.d"
       containers:
-        - name: {{ include "common.name" . }}
-          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
-          imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
-          ports:
-          - containerPort: {{ .Values.service.internalPort }}
-          # disable liveness probe when breakpoints set in debugger
-          # so K8s doesn't restart unresponsive container
-          {{- if eq .Values.liveness.enabled true }}
-          livenessProbe:
-            tcpSocket:
-              port: {{ .Values.service.internalPort }}
-            initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
-            periodSeconds: {{ .Values.liveness.periodSeconds }}
-          {{end -}}
-          readinessProbe:
-            tcpSocket:
-              port: {{ .Values.service.internalPort }}
-            initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
-            periodSeconds: {{ .Values.readiness.periodSeconds }}
-          env:
-            - name: MYSQL_ROOT_PASSWORD
-              valueFrom:
-                secretKeyRef:
-                  name: {{ template "common.fullname" . }}
-                  key: db-root-password
-          volumeMounts:
-          - mountPath: /var/lib/mysql
-            name: mariadb-data
-          - mountPath: /etc/localtime
-            name: localtime
-            readOnly: true
-          - mountPath: /etc/mysql/conf.d
-            name: mariadb-conf
-          - mountPath: /docker-entrypoint-initdb.d/02-load-additional-changes.sh
-            name: mariadb-docker-entrypoint-initdb
-            subPath: 02-load-additional-changes.sh
-          - mountPath: /docker-entrypoint-initdb.d/01-load-default-sql-files.sh
-            name: mariadb-docker-entrypoint-initdb
-            subPath: 01-load-default-sql-files.sh
-          - mountPath: /docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/automated-tests
-            name: mariadb-docker-entrypoint-automated-tests
-          - mountPath: /docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/default
-            name: mariadb-docker-entrypoint-bulkload-default
-          - mountPath: /docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-dns
-            name: mariadb-docker-entrypoint-demo-dns
-          - mountPath: /docker-entrypoint-initdb.d/db-sql-scripts/bulkload-files/demo-vfw
-            name: mariadb-docker-entrypoint-demo-vfw
-          - mountPath: /docker-entrypoint-initdb.d/db-sql-scripts/camunda
-            name: mariadb-docker-entrypoint-camunda
-          - mountPath: /docker-entrypoint-initdb.d/db-sql-scripts/main-schemas
-            name: mariadb-docker-entrypoint-main-schemas
-          resources:
+      - name: {{ include "common.name" . }}
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
+        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+        ports:
+        - containerPort: {{ .Values.service.internalPort }}
+        {{ if eq .Values.liveness.enabled true }}
+        livenessProbe:
+          tcpSocket:
+            port: {{ .Values.service.internalPort }}
+          initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
+          periodSeconds: {{ .Values.liveness.periodSeconds }}
+        {{ end }}
+        readinessProbe:
+          tcpSocket:
+            port: {{ .Values.service.internalPort }}
+          initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
+          periodSeconds: {{ .Values.readiness.periodSeconds }}
+        env:
+          - name: MYSQL_ROOT_PASSWORD
+            valueFrom:
+              secretKeyRef:
+                name: {{ template "common.fullname" . }}
+                key: db-root-password
+        volumeMounts:
+        - mountPath: /var/lib/mysql
+          name: mariadb-data
+        - mountPath: /etc/localtime
+          name: localtime
+          readOnly: true
+        - mountPath: /etc/mysql/conf.d
+          name: mariadb-conf
+        - name: docker-entrypoint-initdb-d
+          mountPath: "/docker-entrypoint-initdb.d"
+        resources:
 {{ toYaml .Values.resources | indent 12 }}
-        {{- if .Values.nodeSelector }}
-        nodeSelector:
+      {{- if .Values.nodeSelector }}
+      nodeSelector:
 {{ toYaml .Values.nodeSelector | indent 10 }}
-        {{- end -}}
-        {{- if .Values.affinity }}
-        affinity:
+      {{- end -}}
+      {{- if .Values.affinity }}
+      affinity:
 {{ toYaml .Values.affinity | indent 10 }}
-        {{- end }}
-      volumes:
-      {{- if .Values.persistence.enabled }}
-        - name: mariadb-data
-          persistentVolumeClaim:
-            claimName: {{ include "common.fullname" . }}
-      {{- else }}
-          emptyDir: {}
       {{- end }}
-        - name: mariadb-conf
-          configMap:
-            name: confd-configmap
-        - name: mariadb-docker-entrypoint-initdb
-          configMap:
-            name: docker-entry-initd-configmap
-        - name: mariadb-docker-entrypoint-automated-tests
-          configMap:
-            name: automated-tests-configmap
-        - name: mariadb-docker-entrypoint-bulkload-default
-          configMap:
-            name: bulkload-default-configmap
-        - name: mariadb-docker-entrypoint-demo-dns
-          configMap:
-            name: demo-dns-configmap
-        - name: mariadb-docker-entrypoint-demo-vfw
-          configMap:
-            name: demo-vfw-configmap
-        - name: mariadb-docker-entrypoint-camunda
-          configMap:
-            name: scripts-camunda-configmap
-        - name: mariadb-docker-entrypoint-main-schemas
-          configMap:
-            name: main-schemas-configmap
-        - name: localtime
-          hostPath:
-            path: /etc/localtime
+      volumes:
+      - name: mariadb-data
+      {{- if .Values.persistence.enabled }}
+        persistentVolumeClaim:
+          claimName: {{ include "common.fullname" . }}
+      {{- else }}
+        emptyDir: {}
+      {{- end }}
+      - name: mariadb-conf
+        configMap:
+          name: confd-configmap
+      - name: localtime
+        hostPath:
+          path: /etc/localtime
+      - name: docker-entrypoint-initdb-d
+        emptyDir: {}
       imagePullSecrets:
       - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/so/charts/mariadb/values.yaml b/kubernetes/so/charts/mariadb/values.yaml
index 1a62071..76d4d09 100644
--- a/kubernetes/so/charts/mariadb/values.yaml
+++ b/kubernetes/so/charts/mariadb/values.yaml
@@ -19,16 +19,23 @@
   nodePortPrefix: 302
   repositorySecret: eyJuZXh1czMub25hcC5vcmc6MTAwMDEiOnsidXNlcm5hbWUiOiJkb2NrZXIiLCJwYXNzd29yZCI6ImRvY2tlciIsImVtYWlsIjoiQCIsImF1dGgiOiJaRzlqYTJWeU9tUnZZMnRsY2c9PSJ9fQ==
   persistence: {}
+  readinessRepository: oomk8s
+  ubuntuInitRepository: registry.hub.docker.com
 
 
 # application image
 repository: nexus3.onap.org:10001
 image: mariadb:10.1.11
 pullPolicy: Always
+ubuntuInitImage: oomk8s/ubuntu-init:2.0.0
 
 # application configuration
 config:
   mariadbRootPassword: password
+  # gerrit branch where the latest heat code is checked in
+  gerritBranch: master
+  # gerrit project where the latest heat code is checked in
+  gerritProject: http://gerrit.onap.org/r/so/docker-config.git
 
 
 # default number of instances
@@ -40,14 +47,14 @@
 
 # probe configuration parameters
 liveness:
-  initialDelaySeconds: 10
+  initialDelaySeconds: 90
   periodSeconds: 10
   # necessary to disable liveness probe when setting breakpoints
   # in debugger so K8s doesn't restart unresponsive container
   enabled: true
 
 readiness:
-  initialDelaySeconds: 10
+  initialDelaySeconds: 90
   periodSeconds: 10
 
 ## Persist data to a persitent volume
diff --git a/kubernetes/so/resources/config/mso/mso-docker.json b/kubernetes/so/resources/config/mso/mso-docker.json
index 92988ba..aa3cac7 100755
--- a/kubernetes/so/resources/config/mso/mso-docker.json
+++ b/kubernetes/so/resources/config/mso/mso-docker.json
@@ -7,12 +7,28 @@
   {
     "mso_config_path": "/etc/mso/config.d/",
 
+    "mso-topology-config":
+    {
+      "msb-server-ip": "{{.Values.config.msb.serviceName}}",
+      "msb-server-port": "{{.Values.config.msb.port}}"
+    },
+
     "mso-api-handler-infra-config":
     {
       "bpelURL": "http://{{.Values.service.name}}:{{.Values.service.internalPort}}",
       "bpelAuth": "786864AA53D0DCD881AED1154230C0C3058D58B9339D2EFB6193A0F0D82530E1",
       "camundaURL": "http://{{.Values.service.name}}:{{.Values.service.internalPort}}",
-      "camundaAuth": "5119D1AF37F671FC01FFAD2151D93EFB2BBB503E879FD07104D024EDDF118FD1"
+      "camundaAuth": "5119D1AF37F671FC01FFAD2151D93EFB2BBB503E879FD07104D024EDDF118FD1",
+      "aaiEndpoint": "https://{{.Values.config.aai.serviceName}}:{{.Values.config.aai.port}}",
+      "aaiAuth": "2630606608347B7124C244AB0FE34F6F",
+      "msoKey": "07a7159d3bf51a0e53be7a8f89699be7"
+    },
+
+    "mso-asdc-controller-config":
+    {
+      "aaiEndpoint": "https://{{.Values.config.aai.serviceName}}:{{.Values.config.aai.port}}",
+      "aaiAuth": "2630606608347B7124C244AB0FE34F6F",
+      "msoKey": "07a7159d3bf51a0e53be7a8f89699be7"
     },
 
     "asdc-connections":
@@ -27,6 +43,10 @@
         "password": "613AF3483E695524F9857643B697FA51C7A9A0951094F53791485BF3458F9EADA37DBACCCEBD0CB242B85B4062745247",
         "pollingInterval": 60,
         "pollingTimeout": 60,
+        "watchDogTimeout": "300",
+        "messageBusAddress": [
+          "{{.Values.config.messagerouter.serviceName}}"
+        ],
         "relevantArtifactTypes": "HEAT,HEAT_ENV,HEAT_VOL",
         "activateServerTLSAuth": "false",
         "keyStorePassword": "",
@@ -46,7 +66,8 @@
         "http://{{.Values.config.sdnc.serviceName}}:{{.Values.config.sdnc.port}}/restconf/operations/NBNC-API:",
         "http://{{.Values.config.sdnc.serviceName}}:{{.Values.config.sdnc.port}}/restconf/operations/NORTHBOUND-API:service-topology-operation",
         "http://{{.Values.config.sdnc.serviceName}}:{{.Values.config.sdnc.port}}/restconf/operations/GENERIC-RESOURCE-API:",
-        "http://{{.Values.config.sdnc.serviceName}}:{{.Values.config.sdnc.port}}/restconf/operations/VNFTOPOLOGYAIC-API:"
+        "http://{{.Values.config.sdnc.serviceName}}:{{.Values.config.sdnc.port}}/restconf/operations/VNFTOPOLOGYAIC-API:",
+        "http://{{.Values.config.sdnc.serviceName}}:{{.Values.config.sdnc.port}}/"
       ],
 
       "bpelurl": "http://{{.Values.service.name}}:{{.Values.service.internalPort}}/mso/SDNCAdapterCallbackService",
@@ -56,6 +77,7 @@
       "bpelauth": "5119D1AF37F671FC01FFAD2151D93EFB2BBB503E879FD07104D024EDDF118FD1",
       "sdncconnecttime": "5000"
     },
+
     "mso-po-adapter-config":
     {
       "identity_services":
@@ -107,7 +129,6 @@
       "ueb_consumer_id": "testuser",
       "ueb_topic": "queuetopic",
       "ueb_polling_interval": "30",
-      "ueb_polling_interval": "30",
       "ueb_user": "user",
       "ueb_password": "1ec0d74615d4e4639f991c0590c83b88",
       "bpel_url": "http://localhost:18080",
@@ -132,6 +153,11 @@
       "sniroTimeout": "PT30M",
       "serviceAgnosticSniroHost": "http://{{.Values.config.sniro.serviceName}}:{{.Values.config.sniro.port}}",
       "serviceAgnosticSniroEndpoint": "/sniro/api/v2/placement",
+      "oofAuth": "test:testpwd",
+      "oofEndpoint": "http://{{.Values.config.oof.serviceName}}:{{.Values.config.oof.port}}/api/oof/v1/placement",
+      "oofTimeout": "PT30M",
+      "serviceAgnosticOofHost": "http://{{.Values.config.oof.serviceName}}:{{.Values.config.oof.port}}",
+      "serviceAgnosticOofEndpoint": "/api/oof/v1/placement",
       "aaiEndpoint": "https://{{.Values.config.aai.serviceName}}:{{.Values.config.aai.port}}",
       "aaiAuth": "2630606608347B7124C244AB0FE34F6F",
       "adaptersNamespace": "http://org.openecomp.mso",
@@ -165,6 +191,17 @@
       "sdncTimeoutFirewall": "20",
       "callbackRetryAttempts": "30",
       "callbackRetrySleepTime": "1000",
+      "appcClientTopicRead": "APPC-LCM-READ",
+      "appcClientTopicWrite": "APPC-LCM-WRITE",
+      "appcClientTopicSdncRead": "SDNC-LCM-READ",
+      "appcClientTopicSdncWrite": "SDNC-LCM-WRITE",
+      "appcClientTopicReadTimeout": "360000",
+      "appcClientResponseTime": "360000",
+      "appcClientPoolMembers": "{{.Values.config.messagerouter.serviceName}}:{{.Values.config.messagerouter.port}}",
+      "appcClientKey": "VIlbtVl6YLhNUrtU",
+      "appcClientSecret": "64AG2hF4pYeG2pq7CT6XwUOT",
+      "appcClientService": "ueb",
+      "sdncSiSvcTypes": "PORT-MIRROR,PPROBE",
       "workflowL3ToHigherLayerAddBondingModelName" : "WAN Bonding",
       "workflowL3ToHigherLayerAddBondingModelVersion" : "2.0"
     }
diff --git a/kubernetes/so/templates/deployment.yaml b/kubernetes/so/templates/deployment.yaml
index bc01727..5b3f697 100644
--- a/kubernetes/so/templates/deployment.yaml
+++ b/kubernetes/so/templates/deployment.yaml
@@ -141,7 +141,7 @@
         affinity:
 {{ toYaml .Values.affinity | indent 10 }}
         {{- end }}
-        
+
         # side car containers
         - name: filebeat-onap
           image: "{{ .Values.global.loggingRepository }}/{{ .Values.global.loggingImage }}"
diff --git a/kubernetes/so/values.yaml b/kubernetes/so/values.yaml
index c92fe2a..9a8e3bf 100644
--- a/kubernetes/so/values.yaml
+++ b/kubernetes/so/values.yaml
@@ -28,7 +28,7 @@
 
 # application image
 repository: nexus3.onap.org:10001
-image: openecomp/mso:1.2-STAGING-latest
+image: openecomp/mso:1.2.1
 pullPolicy: Always
   
 # flag to enable debugging - application support required
@@ -51,10 +51,16 @@
     port: 80
   aai:
     serviceName: aai
-    port: 8080
+    port: 8443
+  messagerouter:
+    serviceName: message-router
+    port: 3904
   msb:
     serviceName: msb-iag
     port: 80
+  oof:
+    serviceName: oof-has-api
+    port: 8091
   sdnc:
     serviceName: sdnc
     port: 8282
diff --git a/kubernetes/uui/charts/uui-server/templates/deployment.yaml b/kubernetes/uui/charts/uui-server/templates/deployment.yaml
index 29fbd64..accdff9 100644
--- a/kubernetes/uui/charts/uui-server/templates/deployment.yaml
+++ b/kubernetes/uui/charts/uui-server/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/uui/templates/deployment.yaml b/kubernetes/uui/templates/deployment.yaml
index 4b3ed7c..9578d9c 100644
--- a/kubernetes/uui/templates/deployment.yaml
+++ b/kubernetes/uui/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           command:
             - /bin/bash
diff --git a/kubernetes/uui/values.yaml b/kubernetes/uui/values.yaml
index 9d76711..1024b2d 100644
--- a/kubernetes/uui/values.yaml
+++ b/kubernetes/uui/values.yaml
@@ -24,7 +24,7 @@
 
 # application image
 repository: nexus3.onap.org:10001
-image: onap/usecase-ui:v1.0.1
+image: onap/usecase-ui:1.1.0-SNAPSHOT-STAGING-latest
 pullPolicy: Always
 
 # application configuration
diff --git a/kubernetes/vfc/charts/vfc-catalog/values.yaml b/kubernetes/vfc/charts/vfc-catalog/values.yaml
index 77b9613..461bad6 100644
--- a/kubernetes/vfc/charts/vfc-catalog/values.yaml
+++ b/kubernetes/vfc/charts/vfc-catalog/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/catalog:1.1.0-SNAPSHOT-latest
+image: onap/vfc/catalog:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-ems-driver/values.yaml b/kubernetes/vfc/charts/vfc-ems-driver/values.yaml
index f732eac..83161ff 100644
--- a/kubernetes/vfc/charts/vfc-ems-driver/values.yaml
+++ b/kubernetes/vfc/charts/vfc-ems-driver/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/emsdriver:1.1.0-SNAPSHOT-latest
+image: onap/vfc/emsdriver:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-generic-vnfm-driver/values.yaml b/kubernetes/vfc/charts/vfc-generic-vnfm-driver/values.yaml
index 1f6deae..493ac1a 100644
--- a/kubernetes/vfc/charts/vfc-generic-vnfm-driver/values.yaml
+++ b/kubernetes/vfc/charts/vfc-generic-vnfm-driver/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/gvnfmdriver:1.1.0-SNAPSHOT-latest
+image: onap/vfc/gvnfmdriver:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-huawei-vnfm-driver/values.yaml b/kubernetes/vfc/charts/vfc-huawei-vnfm-driver/values.yaml
index 073d9d0..d638606 100644
--- a/kubernetes/vfc/charts/vfc-huawei-vnfm-driver/values.yaml
+++ b/kubernetes/vfc/charts/vfc-huawei-vnfm-driver/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/nfvo/svnfm/huawei:1.1.0-SNAPSHOT-latest
+image: onap/vfc/nfvo/svnfm/huawei:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-juju-vnfm-driver/values.yaml b/kubernetes/vfc/charts/vfc-juju-vnfm-driver/values.yaml
index af058af..1632594 100644
--- a/kubernetes/vfc/charts/vfc-juju-vnfm-driver/values.yaml
+++ b/kubernetes/vfc/charts/vfc-juju-vnfm-driver/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/jujudriver:1.1.0-SNAPSHOT-latest
+image: onap/vfc/jujudriver:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-multivim-proxy/values.yaml b/kubernetes/vfc/charts/vfc-multivim-proxy/values.yaml
index fbd144d..8bd45e0 100644
--- a/kubernetes/vfc/charts/vfc-multivim-proxy/values.yaml
+++ b/kubernetes/vfc/charts/vfc-multivim-proxy/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/multivimproxy:1.0.0-SNAPSHOT-latest
+image: onap/vfc/multivimproxy:1.0.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-nokia-vnfm-driver/values.yaml b/kubernetes/vfc/charts/vfc-nokia-vnfm-driver/values.yaml
index 3bc8d8f..0c54305 100644
--- a/kubernetes/vfc/charts/vfc-nokia-vnfm-driver/values.yaml
+++ b/kubernetes/vfc/charts/vfc-nokia-vnfm-driver/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/nfvo/svnfm/nokia:1.1.0-SNAPSHOT-latest
+image: onap/vfc/nfvo/svnfm/nokia:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-nslcm/values.yaml b/kubernetes/vfc/charts/vfc-nslcm/values.yaml
index ee360d5..7bfe6a0 100644
--- a/kubernetes/vfc/charts/vfc-nslcm/values.yaml
+++ b/kubernetes/vfc/charts/vfc-nslcm/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/nslcm:1.1.0-SNAPSHOT-latest
+image: onap/vfc/nslcm:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-resmgr/values.yaml b/kubernetes/vfc/charts/vfc-resmgr/values.yaml
index ba2b01d..dc73a84 100644
--- a/kubernetes/vfc/charts/vfc-resmgr/values.yaml
+++ b/kubernetes/vfc/charts/vfc-resmgr/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/resmanagement:1.1.0-SNAPSHOT-latest
+image: onap/vfc/resmanagement:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-vnflcm/values.yaml b/kubernetes/vfc/charts/vfc-vnflcm/values.yaml
index e7cdc63..0f69dc8 100644
--- a/kubernetes/vfc/charts/vfc-vnflcm/values.yaml
+++ b/kubernetes/vfc/charts/vfc-vnflcm/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/vnflcm:1.1.0-SNAPSHOT-latest
+image: onap/vfc/vnflcm:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-vnfmgr/values.yaml b/kubernetes/vfc/charts/vfc-vnfmgr/values.yaml
index 0ee3dd6..8935538 100644
--- a/kubernetes/vfc/charts/vfc-vnfmgr/values.yaml
+++ b/kubernetes/vfc/charts/vfc-vnfmgr/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/vnfmgr:1.1.0-SNAPSHOT-latest
+image: onap/vfc/vnfmgr:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-vnfres/values.yaml b/kubernetes/vfc/charts/vfc-vnfres/values.yaml
index eb9ff31..79c7682 100644
--- a/kubernetes/vfc/charts/vfc-vnfres/values.yaml
+++ b/kubernetes/vfc/charts/vfc-vnfres/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/vnfres:1.1.0-SNAPSHOT-latest
+image: onap/vfc/vnfres:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-workflow-engine/values.yaml b/kubernetes/vfc/charts/vfc-workflow-engine/values.yaml
index 10dbea8..73e3d7c 100644
--- a/kubernetes/vfc/charts/vfc-workflow-engine/values.yaml
+++ b/kubernetes/vfc/charts/vfc-workflow-engine/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/wfengine-activiti:1.1.0-SNAPSHOT-latest
+image: onap/vfc/wfengine-activiti:latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-workflow/values.yaml b/kubernetes/vfc/charts/vfc-workflow/values.yaml
index 37c36d3..2cba45e 100644
--- a/kubernetes/vfc/charts/vfc-workflow/values.yaml
+++ b/kubernetes/vfc/charts/vfc-workflow/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/wfengine-mgrservice:1.1.0-SNAPSHOT-latest
+image: onap/vfc/wfengine-mgrservice:latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-zte-sdnc-driver/values.yaml b/kubernetes/vfc/charts/vfc-zte-sdnc-driver/values.yaml
index b1f006a..06ebbf0 100644
--- a/kubernetes/vfc/charts/vfc-zte-sdnc-driver/values.yaml
+++ b/kubernetes/vfc/charts/vfc-zte-sdnc-driver/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/ztesdncdriver:1.1.0-SNAPSHOT-latest
+image: onap/vfc/ztesdncdriver:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vfc/charts/vfc-zte-vnfm-driver/values.yaml b/kubernetes/vfc/charts/vfc-zte-vnfm-driver/values.yaml
index e6f8ecc..68ffe76 100644
--- a/kubernetes/vfc/charts/vfc-zte-vnfm-driver/values.yaml
+++ b/kubernetes/vfc/charts/vfc-zte-vnfm-driver/values.yaml
@@ -28,7 +28,7 @@
 #################################################################
 # application image
 repository: nexus3.onap.org:10001
-image: onap/vfc/ztevnfmdriver:1.1.0-SNAPSHOT-latest
+image: onap/vfc/ztevnfmdriver:1.1.0-STAGING-latest
 pullPolicy: Always
 
 # flag to enable debugging - application support required
diff --git a/kubernetes/vid/charts/mariadb/templates/deployment.yaml b/kubernetes/vid/charts/mariadb/templates/deployment.yaml
index cafab0c..0560f60 100644
--- a/kubernetes/vid/charts/mariadb/templates/deployment.yaml
+++ b/kubernetes/vid/charts/mariadb/templates/deployment.yaml
@@ -32,7 +32,7 @@
     spec:
       containers:
         - name: {{ include "common.name" . }}
-          image: {{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           ports:
           - containerPort: {{ .Values.service.internalPort }}
diff --git a/kubernetes/vid/templates/deployment.yaml b/kubernetes/vid/templates/deployment.yaml
index 5491808..46f3ea0 100644
--- a/kubernetes/vid/templates/deployment.yaml
+++ b/kubernetes/vid/templates/deployment.yaml
@@ -47,7 +47,7 @@
         name: {{ include "common.name" . }}-readiness
       containers:
         - name: {{ include "common.name" . }}
-          image: "{{ .Values.global.repository | default .Values.repository }}/{{ .Values.image }}"
+          image: "{{ include "common.repository" . }}/{{ .Values.image }}"
           imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
           lifecycle:
             postStart:
