diff --git a/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-bundle/pom.xml b/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-bundle/pom.xml
index 8f4fe99..b2b0338 100644
--- a/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-bundle/pom.xml
+++ b/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-bundle/pom.xml
@@ -19,7 +19,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
   
-  ECOMP is a trademark and service mark of AT&T Intellectual Property.
   ============LICENSE_END=========================================================
   -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
@@ -174,7 +173,6 @@
                 <dependency>
                    <groupId>com.google.guava</groupId>
                   <artifactId>guava</artifactId>
-                  <version>20.0</version>
           </dependency>
 
                 <!-- 
diff --git a/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-features/src/main/resources/features.xml b/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-features/src/main/resources/features.xml
index 69d3b9b..a4ebe1d 100644
--- a/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-features/src/main/resources/features.xml
+++ b/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-features/src/main/resources/features.xml
@@ -3,7 +3,7 @@
   ============LICENSE_START=======================================================
   ONAP : APPC
   ================================================================================
-  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   ================================================================================
   Copyright (C) 2017 Amdocs
   =============================================================================
@@ -19,7 +19,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
   
-  ECOMP is a trademark and service mark of AT&T Intellectual Property.
   ============LICENSE_END=========================================================
   -->
 
@@ -28,11 +27,11 @@
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">     
 
-     <repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>
+     <!--<repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>-->
     
     <feature name='appc-ansible-adapter' description="appc-ansible-adapter" version='${project.version}'>
-        <feature version="${odl.mdsal.version}">odl-mdsal-broker</feature>
-        <feature>sdnc-sli</feature>
+        <feature >odl-mdsal-broker</feature>
+        <feature>ccsdk-sli</feature>
          <bundle dependency="true">mvn:org.onap.appc/appc-common/${project.version}</bundle>
         <bundle>mvn:org.onap.appc/appc-ansible-adapter-bundle/${project.version}</bundle>
     </feature>
diff --git a/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-installer/src/main/resources/scripts/install-feature.sh b/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-installer/src/main/resources/scripts/install-feature.sh
index 05b4ae3..c3c0368 100644
--- a/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-installer/src/main/resources/scripts/install-feature.sh
+++ b/appc-adapters/appc-ansible-adapter/appc-ansible-adapter-installer/src/main/resources/scripts/install-feature.sh
@@ -2,7 +2,7 @@
 # ============LICENSE_START=======================================================
 # ONAP : APPC
 # ================================================================================
-# Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+# Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
 # ================================================================================
 # Copyright (C) 2017 Amdocs
 # =============================================================================
@@ -18,7 +18,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # 
-# ECOMP is a trademark and service mark of AT&T Intellectual Property.
 # ============LICENSE_END=========================================================
 ###
 
@@ -26,7 +25,7 @@
 
 ODL_HOME=${ODL_HOME:-/opt/opendaylight/current}
 ODL_KARAF_CLIENT=${ODL_KARAF_CLIENT:-${ODL_HOME}/bin/client}
-ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-"-u karaf"}
+ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-""}
 INSTALLERDIR=$(dirname $0)
 
 REPOZIP=${INSTALLERDIR}/${features.boot}-${project.version}.zip
@@ -40,4 +39,4 @@
 fi
 
 ${ODL_KARAF_CLIENT} ${ODL_KARAF_CLIENT_OPTS} feature:repo-add ${features.repositories}
-${ODL_KARAF_CLIENT} ${ODL_KARAF_CLIENT_OPTS} feature:install ${features.boot}
+
diff --git a/appc-adapters/appc-chef-adapter/appc-chef-adapter-features/src/main/resources/features.xml b/appc-adapters/appc-chef-adapter/appc-chef-adapter-features/src/main/resources/features.xml
index e3cd710..e385449 100644
--- a/appc-adapters/appc-chef-adapter/appc-chef-adapter-features/src/main/resources/features.xml
+++ b/appc-adapters/appc-chef-adapter/appc-chef-adapter-features/src/main/resources/features.xml
@@ -3,7 +3,7 @@
   ============LICENSE_START=======================================================
   ONAP : APPC
   ================================================================================
-  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   ================================================================================
   Copyright (C) 2017 Amdocs
   =============================================================================
@@ -19,7 +19,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
   
-  ECOMP is a trademark and service mark of AT&T Intellectual Property.
   ============LICENSE_END=========================================================
   -->
 
@@ -28,12 +27,12 @@
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
 
-    <repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>
+    <!--<repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>-->
 
     <feature name='appc-chef-adapter' description="appc-chef-adapter" version='${project.version}'>
         <!-- Most applications will have a dependency on the ODL MD-SAL Broker -->
-        <feature version="${odl.mdsal.version}">odl-mdsal-broker</feature>
-        <feature>sdnc-sli</feature>
+        <feature >odl-mdsal-broker</feature>
+        <feature>ccsdk-sli</feature>
         <bundle dependency="true">mvn:org.onap.appc/appc-common/${project.version}</bundle>
         <bundle>mvn:org.onap.appc/appc-chef-adapter-bundle/${project.version}</bundle>
     </feature>
diff --git a/appc-adapters/appc-chef-adapter/appc-chef-adapter-installer/src/main/resources/scripts/install-feature.sh b/appc-adapters/appc-chef-adapter/appc-chef-adapter-installer/src/main/resources/scripts/install-feature.sh
index d0210eb..cd1b4d9 100644
--- a/appc-adapters/appc-chef-adapter/appc-chef-adapter-installer/src/main/resources/scripts/install-feature.sh
+++ b/appc-adapters/appc-chef-adapter/appc-chef-adapter-installer/src/main/resources/scripts/install-feature.sh
@@ -2,7 +2,7 @@
 # ============LICENSE_START=======================================================
 # ONAP : APPC
 # ================================================================================
-# Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+# Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
 # ================================================================================
 # Copyright (C) 2017 Amdocs
 # =============================================================================
@@ -18,7 +18,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # 
-# ECOMP is a trademark and service mark of AT&T Intellectual Property.
 # ============LICENSE_END=========================================================
 ###
 
@@ -26,7 +25,7 @@
 
 ODL_HOME=${ODL_HOME:-/opt/opendaylight/current}
 ODL_KARAF_CLIENT=${ODL_KARAF_CLIENT:-${ODL_HOME}/bin/client}
-ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-"-u karaf"}
+ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-""}
 INSTALLERDIR=$(dirname $0)
 
 REPOZIP=${INSTALLERDIR}/${features.boot}-${project.version}.zip
@@ -40,4 +39,4 @@
 fi
 
 ${ODL_KARAF_CLIENT} ${ODL_KARAF_CLIENT_OPTS} feature:repo-add ${features.repositories}
-${ODL_KARAF_CLIENT} ${ODL_KARAF_CLIENT_OPTS} feature:install ${features.boot}
+
diff --git a/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-bundle/pom.xml b/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-bundle/pom.xml
index 86029b6..8928709 100644
--- a/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-bundle/pom.xml
+++ b/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-bundle/pom.xml
@@ -18,7 +18,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
   ============LICENSE_END=========================================================
-  ECOMP is a trademark and service mark of AT&T Intellectual Property.
   -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
@@ -176,7 +175,7 @@
 						<!--<Bundle-SymbolicName>org.onap.appc.adapter.messaging.dmaap</Bundle-SymbolicName>-->
 						<Bundle-Activator>org.onap.appc.adapter.messaging.dmaap.AppcDmaapAdapterActivator</Bundle-Activator>
 						<Export-Package>org.onap.appc.adapter.messaging.*</Export-Package>
-						<Import-Package>!org.slf4j.event,org.onap.appc.adapter.message.*,org.onap.appc.metricservice.*,com.att.nsa.*,org.onap.ccsdk.sli.core.sli.*,org.osgi.framework.*,!org.osgi.service.event.*,org.osgi.service.*,org.osgi.util.*,org.slf4j.*,com.vmware.*,org.apache.xerces.*,javax.net.ssl.*,org.xml.sax.*,javax.xml.*,javax.naming.*,javax.crypto.*, com.sun.jersey.spi.container.servlet,org.eclipse.jetty.servlets,org.w3c.*</Import-Package>
+						<Import-Package>!org.slf4j.event,org.onap.appc.adapter.message.*,org.onap.appc.metricservice.*,com.att.nsa.*,org.onap.ccsdk.sli.core.sli.*,org.osgi.framework.*,!org.osgi.service.event.*,org.osgi.service.*,org.osgi.util.*,org.slf4j.*,com.vmware.*,org.apache.xerces.*,javax.net.ssl.*,org.xml.sax.*,javax.xml.*,javax.naming.*,javax.crypto.*, com.sun.jersey.spi.container.servlet,org.eclipse.jetty.servlets</Import-Package>
 						<Embed-Dependency>*;scope=compile|runtime;artifactId=!appc-metric-bundle|appc-message-adapter-api|sli-common|org.eclipse.osgi|slf4j-api|jcl-over-slf4j|mariadb-java-client|xml-apis|pax-*</Embed-Dependency>
 						<Embed-Transitive>true</Embed-Transitive>
 						<Bundle-Blueprint>OSGI-INF/blueprint/blueprint.xml</Bundle-Blueprint>
diff --git a/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-features/src/main/resources/features.xml b/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-features/src/main/resources/features.xml
index 5762140..e237139 100644
--- a/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-features/src/main/resources/features.xml
+++ b/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-features/src/main/resources/features.xml
@@ -3,7 +3,7 @@
   ============LICENSE_START=======================================================
   ONAP : APPC
   ================================================================================
-  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   ================================================================================
   Copyright (C) 2017 Amdocs
   =============================================================================
@@ -19,7 +19,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
   
-  ECOMP is a trademark and service mark of AT&T Intellectual Property.
   ============LICENSE_END=========================================================
   -->
 
@@ -29,13 +28,13 @@
     xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">     
     
 <!--     <repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.version}/xml/features</repository> -->
-    <repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>
+    <!--<repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>-->
     
     <feature name='appc-dmaap-adapter' description="appc-dmaap-adapter" version='${project.version}'>
         <!-- Most applications will have a dependency on the ODL MD-SAL Broker -->
-<!--         <feature version="${odl.mdsal.version}">odl-mdsal-broker</feature> -->
-        <feature version="${odl.mdsal.version}">odl-mdsal-broker</feature>
-<!--         <feature version="${sdnctl.sli.version}">sdnc-sli</feature> -->
+<!--         <feature >odl-mdsal-broker</feature> -->
+        <feature >odl-mdsal-broker</feature>
+<!--         <feature version="${sdnctl.sli.version}">ccsdk-sli</feature> -->
         <bundle>mvn:org.onap.appc/appc-dmaap-adapter-bundle/${project.version}</bundle>
         <bundle>mvn:org.onap.appc/appc-message-adapter-factory/${project.version}</bundle>
         <bundle>mvn:org.onap.appc/appc-message-adapter-api/${project.version}</bundle>
diff --git a/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-installer/src/main/resources/scripts/install-feature.sh b/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-installer/src/main/resources/scripts/install-feature.sh
index 13d41ca..6c2a503 100644
--- a/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-installer/src/main/resources/scripts/install-feature.sh
+++ b/appc-adapters/appc-dmaap-adapter/appc-dmaap-adapter-installer/src/main/resources/scripts/install-feature.sh
@@ -2,7 +2,7 @@
 # ============LICENSE_START=======================================================
 # ONAP : APPC
 # ================================================================================
-# Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+# Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
 # ================================================================================
 # Copyright (C) 2017 Amdocs
 # =============================================================================
@@ -18,7 +18,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # 
-# ECOMP is a trademark and service mark of AT&T Intellectual Property.
 # ============LICENSE_END=========================================================
 ###
 
@@ -26,7 +25,7 @@
 
 ODL_HOME=${ODL_HOME:-/opt/opendaylight/current}
 ODL_KARAF_CLIENT=${ODL_KARAF_CLIENT:-${ODL_HOME}/bin/client}
-ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-"-u karaf"}
+ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-""}
 INSTALLERDIR=$(dirname $0)
 
 REPOZIP=${INSTALLERDIR}/${features.boot}-${project.version}.zip
@@ -50,14 +49,3 @@
 	fi
 	let COUNT=COUNT+1
 done
-COUNT=0
-while [ $COUNT -lt 10 ]; do
-	${ODL_KARAF_CLIENT} ${ODL_KARAF_CLIENT_OPTS} feature:install ${features.boot} 2> /tmp/installErr
-		cat /tmp/installErr
-	if grep -q 'Failed to get the session' /tmp/installErr; then
-		sleep 10
-	else
-		let COUNT=10
-	fi
-	let COUNT=COUNT+1
-done
diff --git a/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-bundle/src/test/java/org/onap/appc/adapter/iaas/AppcProviderAdapterActivatorTest.java b/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-bundle/src/test/java/org/onap/appc/adapter/iaas/AppcProviderAdapterActivatorTest.java
index 7a8d9ab..4b272bc 100644
--- a/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-bundle/src/test/java/org/onap/appc/adapter/iaas/AppcProviderAdapterActivatorTest.java
+++ b/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-bundle/src/test/java/org/onap/appc/adapter/iaas/AppcProviderAdapterActivatorTest.java
@@ -41,7 +41,7 @@
 public class AppcProviderAdapterActivatorTest {
 
     @Mock
-    private ServiceRegistration<ProviderAdapter> serviceRegistration;
+    private ServiceRegistration serviceRegistration;
     @Mock
     private BundleContext bundleContext;
 
diff --git a/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-features/src/main/resources/features.xml b/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-features/src/main/resources/features.xml
index 7a081c0..5d76cfb 100644
--- a/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-features/src/main/resources/features.xml
+++ b/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-features/src/main/resources/features.xml
@@ -3,7 +3,7 @@
   ============LICENSE_START=======================================================
   ONAP : APPC
   ================================================================================
-  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   ================================================================================
   Copyright (C) 2017 Amdocs
   =============================================================================
@@ -19,7 +19,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
   
-  ECOMP is a trademark and service mark of AT&T Intellectual Property.
   ============LICENSE_END=========================================================
   -->
 
@@ -29,15 +28,15 @@
     xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">     
     
 <!--     <repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.version}/xml/features</repository> -->
-    <repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>
+    <!--<repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>-->
 <!--     <repository>mvn:org.ops4j.pax.web/pax-web-features/6.0.3/xml/features</repository> -->
     
 
     <feature name='appc-iaas-adapter' description="appc-iaas-adapter" version='${project.version}'>
         <!-- Most applications will have a dependency on the ODL MD-SAL Broker -->
 <!--         <feature>pax-jetty</feature> -->
-        <feature version="${odl.mdsal.version}">odl-mdsal-broker</feature>
-        <feature>sdnc-sli</feature>
+        <feature >odl-mdsal-broker</feature>
+        <feature>ccsdk-sli</feature>
         <bundle>mvn:org.onap.appc/appc-iaas-adapter-bundle/${project.version}</bundle>
 
     </feature>
diff --git a/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-installer/src/main/resources/scripts/install-feature.sh b/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-installer/src/main/resources/scripts/install-feature.sh
index 13d41ca..6c2a503 100644
--- a/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-installer/src/main/resources/scripts/install-feature.sh
+++ b/appc-adapters/appc-iaas-adapter/appc-iaas-adapter-installer/src/main/resources/scripts/install-feature.sh
@@ -2,7 +2,7 @@
 # ============LICENSE_START=======================================================
 # ONAP : APPC
 # ================================================================================
-# Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+# Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
 # ================================================================================
 # Copyright (C) 2017 Amdocs
 # =============================================================================
@@ -18,7 +18,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # 
-# ECOMP is a trademark and service mark of AT&T Intellectual Property.
 # ============LICENSE_END=========================================================
 ###
 
@@ -26,7 +25,7 @@
 
 ODL_HOME=${ODL_HOME:-/opt/opendaylight/current}
 ODL_KARAF_CLIENT=${ODL_KARAF_CLIENT:-${ODL_HOME}/bin/client}
-ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-"-u karaf"}
+ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-""}
 INSTALLERDIR=$(dirname $0)
 
 REPOZIP=${INSTALLERDIR}/${features.boot}-${project.version}.zip
@@ -50,14 +49,3 @@
 	fi
 	let COUNT=COUNT+1
 done
-COUNT=0
-while [ $COUNT -lt 10 ]; do
-	${ODL_KARAF_CLIENT} ${ODL_KARAF_CLIENT_OPTS} feature:install ${features.boot} 2> /tmp/installErr
-		cat /tmp/installErr
-	if grep -q 'Failed to get the session' /tmp/installErr; then
-		sleep 10
-	else
-		let COUNT=10
-	fi
-	let COUNT=COUNT+1
-done
diff --git a/appc-adapters/appc-netconf-adapter/appc-netconf-adapter-features/src/main/resources/features.xml b/appc-adapters/appc-netconf-adapter/appc-netconf-adapter-features/src/main/resources/features.xml
index 61d9a0a..4ae53d1 100644
--- a/appc-adapters/appc-netconf-adapter/appc-netconf-adapter-features/src/main/resources/features.xml
+++ b/appc-adapters/appc-netconf-adapter/appc-netconf-adapter-features/src/main/resources/features.xml
@@ -3,7 +3,7 @@
   ============LICENSE_START=======================================================
   ONAP : APPC
   ================================================================================
-  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   ================================================================================
   Copyright (C) 2017 Amdocs
   =============================================================================
@@ -19,7 +19,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
   
-  ECOMP is a trademark and service mark of AT&T Intellectual Property.
   ============LICENSE_END=========================================================
   -->
 
@@ -28,11 +27,11 @@
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
 
-    <repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>
+    <!--<repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>-->
 
     <feature name='appc-netconf-adapter' description="appc-netconf-adapter" version='${project.version}'>
         <!-- Most applications will have a dependency on the ODL MD-SAL Broker -->
-        <feature version="${odl.mdsal.version}">odl-mdsal-broker</feature>
+        <feature >odl-mdsal-broker</feature>
 <!--         <bundle>mvn:org.onap.appc/appc-dmaap-adapter-bundle/${project.version}</bundle> -->
         <bundle dependency="true">mvn:org.onap.appc/appc-common/${project.version}</bundle>
         <bundle start-level="75">mvn:org.onap.ccsdk.sli.core/dblib-provider/${sdnctl.dblib.version}</bundle>
diff --git a/appc-adapters/appc-netconf-adapter/appc-netconf-installer/src/main/resources/scripts/install-feature.sh b/appc-adapters/appc-netconf-adapter/appc-netconf-installer/src/main/resources/scripts/install-feature.sh
index 13d41ca..6c2a503 100644
--- a/appc-adapters/appc-netconf-adapter/appc-netconf-installer/src/main/resources/scripts/install-feature.sh
+++ b/appc-adapters/appc-netconf-adapter/appc-netconf-installer/src/main/resources/scripts/install-feature.sh
@@ -2,7 +2,7 @@
 # ============LICENSE_START=======================================================
 # ONAP : APPC
 # ================================================================================
-# Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+# Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
 # ================================================================================
 # Copyright (C) 2017 Amdocs
 # =============================================================================
@@ -18,7 +18,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # 
-# ECOMP is a trademark and service mark of AT&T Intellectual Property.
 # ============LICENSE_END=========================================================
 ###
 
@@ -26,7 +25,7 @@
 
 ODL_HOME=${ODL_HOME:-/opt/opendaylight/current}
 ODL_KARAF_CLIENT=${ODL_KARAF_CLIENT:-${ODL_HOME}/bin/client}
-ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-"-u karaf"}
+ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-""}
 INSTALLERDIR=$(dirname $0)
 
 REPOZIP=${INSTALLERDIR}/${features.boot}-${project.version}.zip
@@ -50,14 +49,3 @@
 	fi
 	let COUNT=COUNT+1
 done
-COUNT=0
-while [ $COUNT -lt 10 ]; do
-	${ODL_KARAF_CLIENT} ${ODL_KARAF_CLIENT_OPTS} feature:install ${features.boot} 2> /tmp/installErr
-		cat /tmp/installErr
-	if grep -q 'Failed to get the session' /tmp/installErr; then
-		sleep 10
-	else
-		let COUNT=10
-	fi
-	let COUNT=COUNT+1
-done
diff --git a/appc-adapters/appc-rest-adapter/appc-rest-adapter-features/src/main/resources/features.xml b/appc-adapters/appc-rest-adapter/appc-rest-adapter-features/src/main/resources/features.xml
index 8ab5825..2772d55 100644
--- a/appc-adapters/appc-rest-adapter/appc-rest-adapter-features/src/main/resources/features.xml
+++ b/appc-adapters/appc-rest-adapter/appc-rest-adapter-features/src/main/resources/features.xml
@@ -3,7 +3,7 @@
   ============LICENSE_START=======================================================
   ONAP : APPC
   ================================================================================
-  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   ================================================================================
   Copyright (C) 2017 Amdocs
   =============================================================================
@@ -19,7 +19,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
   
-  ECOMP is a trademark and service mark of AT&T Intellectual Property.
   ============LICENSE_END=========================================================
   -->
 
@@ -28,12 +27,12 @@
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">     
     
-    <repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>
+    <!--<repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>-->
 
     <feature name='appc-rest-adapter' description="appc-rest-adapter" version='${project.version}'>
         <!-- Most applications will have a dependency on the ODL MD-SAL Broker -->
-        <feature version="${odl.mdsal.version}">odl-mdsal-broker</feature>
-        <feature>sdnc-sli</feature>
+        <feature >odl-mdsal-broker</feature>
+        <feature>ccsdk-sli</feature>
         <bundle>mvn:org.onap.appc/appc-rest-adapter-bundle/${project.version}</bundle>
     </feature>
 
diff --git a/appc-adapters/appc-rest-adapter/appc-rest-adapter-installer/src/main/resources/scripts/install-feature.sh b/appc-adapters/appc-rest-adapter/appc-rest-adapter-installer/src/main/resources/scripts/install-feature.sh
index 13d41ca..6c2a503 100644
--- a/appc-adapters/appc-rest-adapter/appc-rest-adapter-installer/src/main/resources/scripts/install-feature.sh
+++ b/appc-adapters/appc-rest-adapter/appc-rest-adapter-installer/src/main/resources/scripts/install-feature.sh
@@ -2,7 +2,7 @@
 # ============LICENSE_START=======================================================
 # ONAP : APPC
 # ================================================================================
-# Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+# Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
 # ================================================================================
 # Copyright (C) 2017 Amdocs
 # =============================================================================
@@ -18,7 +18,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # 
-# ECOMP is a trademark and service mark of AT&T Intellectual Property.
 # ============LICENSE_END=========================================================
 ###
 
@@ -26,7 +25,7 @@
 
 ODL_HOME=${ODL_HOME:-/opt/opendaylight/current}
 ODL_KARAF_CLIENT=${ODL_KARAF_CLIENT:-${ODL_HOME}/bin/client}
-ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-"-u karaf"}
+ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-""}
 INSTALLERDIR=$(dirname $0)
 
 REPOZIP=${INSTALLERDIR}/${features.boot}-${project.version}.zip
@@ -50,14 +49,3 @@
 	fi
 	let COUNT=COUNT+1
 done
-COUNT=0
-while [ $COUNT -lt 10 ]; do
-	${ODL_KARAF_CLIENT} ${ODL_KARAF_CLIENT_OPTS} feature:install ${features.boot} 2> /tmp/installErr
-		cat /tmp/installErr
-	if grep -q 'Failed to get the session' /tmp/installErr; then
-		sleep 10
-	else
-		let COUNT=10
-	fi
-	let COUNT=COUNT+1
-done
diff --git a/appc-adapters/appc-rest-healthcheck-adapter/appc-rest-healthcheck-adapter-features/src/main/resources/features.xml b/appc-adapters/appc-rest-healthcheck-adapter/appc-rest-healthcheck-adapter-features/src/main/resources/features.xml
index 0b9d736..304c44b 100644
--- a/appc-adapters/appc-rest-healthcheck-adapter/appc-rest-healthcheck-adapter-features/src/main/resources/features.xml
+++ b/appc-adapters/appc-rest-healthcheck-adapter/appc-rest-healthcheck-adapter-features/src/main/resources/features.xml
@@ -3,7 +3,7 @@
   ============LICENSE_START=======================================================
   ONAP : APPC
   ================================================================================
-  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   ================================================================================
   Copyright (C) 2017 Amdocs
   =============================================================================
@@ -19,7 +19,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
   
-  ECOMP is a trademark and service mark of AT&T Intellectual Property.
   ============LICENSE_END=========================================================
   -->
 
@@ -28,12 +27,12 @@
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">     
     
-    <repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>
+    <!--<repository>mvn:org.opendaylight.mdsal/features-mdsal/${odl.mdsal.features.version}/xml/features</repository>-->
 
     <feature name='appc-rest-healthcheck-adapter' description="appc-rest-healthcheck-adapter" version='${project.version}'>
         <!-- Most applications will have a dependency on the ODL MD-SAL Broker -->
-        <feature version="${odl.mdsal.version}">odl-mdsal-broker</feature>
-        <feature>sdnc-sli</feature>
+        <feature >odl-mdsal-broker</feature>
+        <feature>ccsdk-sli</feature>
         <bundle>mvn:org.onap.appc/appc-rest-healthcheck-adapter-bundle/${project.version}</bundle>
     </feature>
 
diff --git a/appc-adapters/appc-rest-healthcheck-adapter/appc-rest-healthcheck-adapter-installer/src/main/resources/scripts/install-feature.sh b/appc-adapters/appc-rest-healthcheck-adapter/appc-rest-healthcheck-adapter-installer/src/main/resources/scripts/install-feature.sh
index 05b4ae3..c3c0368 100644
--- a/appc-adapters/appc-rest-healthcheck-adapter/appc-rest-healthcheck-adapter-installer/src/main/resources/scripts/install-feature.sh
+++ b/appc-adapters/appc-rest-healthcheck-adapter/appc-rest-healthcheck-adapter-installer/src/main/resources/scripts/install-feature.sh
@@ -2,7 +2,7 @@
 # ============LICENSE_START=======================================================
 # ONAP : APPC
 # ================================================================================
-# Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+# Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
 # ================================================================================
 # Copyright (C) 2017 Amdocs
 # =============================================================================
@@ -18,7 +18,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # 
-# ECOMP is a trademark and service mark of AT&T Intellectual Property.
 # ============LICENSE_END=========================================================
 ###
 
@@ -26,7 +25,7 @@
 
 ODL_HOME=${ODL_HOME:-/opt/opendaylight/current}
 ODL_KARAF_CLIENT=${ODL_KARAF_CLIENT:-${ODL_HOME}/bin/client}
-ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-"-u karaf"}
+ODL_KARAF_CLIENT_OPTS=${ODL_KARAF_CLIENT_OPTS:-""}
 INSTALLERDIR=$(dirname $0)
 
 REPOZIP=${INSTALLERDIR}/${features.boot}-${project.version}.zip
@@ -40,4 +39,4 @@
 fi
 
 ${ODL_KARAF_CLIENT} ${ODL_KARAF_CLIENT_OPTS} feature:repo-add ${features.repositories}
-${ODL_KARAF_CLIENT} ${ODL_KARAF_CLIENT_OPTS} feature:install ${features.boot}
+
diff --git a/appc-adapters/appc-ssh-adapter/appc-ssh-adapter-features/src/main/resources/features.xml b/appc-adapters/appc-ssh-adapter/appc-ssh-adapter-features/src/main/resources/features.xml
index 1243468..de1e813 100644
--- a/appc-adapters/appc-ssh-adapter/appc-ssh-adapter-features/src/main/resources/features.xml
+++ b/appc-adapters/appc-ssh-adapter/appc-ssh-adapter-features/src/main/resources/features.xml
@@ -3,7 +3,7 @@
   ============LICENSE_START=======================================================
   ONAP : APPC
   ================================================================================
-  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   ================================================================================
   Copyright (C) 2017 Amdocs
   =============================================================================
@@ -19,7 +19,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
   
-  ECOMP is a trademark and service mark of AT&T Intellectual Property.
   ============LICENSE_END=========================================================
   -->
 
@@ -28,7 +27,7 @@
 		  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 		  xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
 	<feature name='appc-ssh-adapter' description="appc-ssh-adapter" version='${project.version}'>
-<!--         <feature version='${sdnctl.dblib.version}'>sdnc-dblib</feature> -->
+<!--         <feature version='${sdnctl.dblib.version}'>ccsdk-dblib</feature> -->
         <bundle dependency="true">mvn:org.onap.appc/appc-common/${project.version}</bundle>
 		<bundle>mvn:org.onap.appc/appc-ssh-adapter-api/${project.version}</bundle>
 		<bundle>mvn:org.onap.appc/appc-ssh-adapter-sshd/${project.version}</bundle>
