diff --git a/apps/actn-mdsc/actn-mdscapp/app.xml b/apps/actn-mdsc/actn-mdscapp/app.xml
deleted file mode 100644
index 575ea64..0000000
--- a/apps/actn-mdsc/actn-mdscapp/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.actn.mdsc" origin="Huawei" version="${project.version}"
-     category="default" url="http://onosproject.org" title="ACTN MDSC App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-actn-mdsc-tetunnel-pce/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-actn-mdsc-tetunnel-ctl/${project.version}</artifact>
-    <apps>org.onosproject.tetopology, org.onosproject.tetunnel</apps>
-</app>
diff --git a/apps/actn-mdsc/actn-mdscapp/features.xml b/apps/actn-mdsc/actn-mdscapp/features.xml
deleted file mode 100644
index 7466bc9..0000000
--- a/apps/actn-mdsc/actn-mdscapp/features.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <feature>onos-apps-tetopology-app</feature>
-        <feature>onos-apps-tetunnel-app</feature>
-        <bundle>mvn:${project.groupId}/onos-actn-mdsc-tetunnel-pce/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-actn-mdsc-tetunnel-ctl/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/bgprouter/app.xml b/apps/bgprouter/app.xml
deleted file mode 100644
index c1c2aa7..0000000
--- a/apps/bgprouter/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.bgprouter" origin="Open Networking Foundation" version="${project.version}"
-     category="Traffic Steering" url="http://onosproject.org" title="BGP Router App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}" apps="fibinstaller">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-routing-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-routing-common/${project.version}</artifact>
-</app>
diff --git a/apps/bgprouter/features.xml b/apps/bgprouter/features.xml
deleted file mode 100644
index aeba2fd..0000000
--- a/apps/bgprouter/features.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-routing-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-proxyarp/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-bgprouter/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-routing-common/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/castor/app.xml b/apps/castor/app.xml
deleted file mode 100644
index fe1aab7..0000000
--- a/apps/castor/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.castor" origin="Open Networking Foundation" version="${project.version}"
-     category="default" url="http://onosproject.org"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-routing-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-routing-common/${project.version}</artifact>
-</app>
diff --git a/apps/castor/features.xml b/apps/castor/features.xml
deleted file mode 100644
index 0ddd35b..0000000
--- a/apps/castor/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="onos-apps-castor" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-castor/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-routing-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-routing-common/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/cpman/app/app.xml b/apps/cpman/app/app.xml
deleted file mode 100644
index 6e602ad..0000000
--- a/apps/cpman/app/app.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.cpman" origin="Open Networking Foundation" version="${project.version}"
-     category="Monitoring" url="http://onosproject.org" title="Control Plane Management App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}" apps="org.onosproject.openflow-message">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-cpman-app/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-cpman-api/${project.version}</artifact>
-</app>
diff --git a/apps/cpman/app/features.xml b/apps/cpman/app/features.xml
deleted file mode 100644
index 5e845e5..0000000
--- a/apps/cpman/app/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-cpman-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-cpman/${project.version}</bundle>
-        <bundle>wrap:mvn:org.rrd4j/rrd4j/3.1$Bundle-SymbolicName=rrd4j&amp;Bundle-Version=3.1</bundle>
-    </feature>
-</features>
diff --git a/apps/dhcp/app/app.xml b/apps/dhcp/app/app.xml
deleted file mode 100644
index 575ed41..0000000
--- a/apps/dhcp/app/app.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.dhcp" origin="Open Networking Foundation" version="${project.version}"
-     category="Utility" url="http://onosproject.org" title="DHCP App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-dhcp-api/${project.version}</artifact>
-</app>
diff --git a/apps/dhcp/app/features.xml b/apps/dhcp/app/features.xml
deleted file mode 100644
index 11a6a7e..0000000
--- a/apps/dhcp/app/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-dhcp-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-dhcp/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/faultmanagement/app/app.xml b/apps/faultmanagement/app/app.xml
deleted file mode 100644
index 33c2653..0000000
--- a/apps/faultmanagement/app/app.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.faultmanagement" origin="BTI Systems" version="${project.version}"
-     category="Monitoring" url="https://wiki.onosproject.org/display/ONOS/Fault+Management" title="Fault Management App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-faultmanagement-fmmgr/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-faultmanagement-fmweb/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-faultmanagement-fmgui/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-faultmanagement-fmcli/${project.version}</artifact>
-</app>
diff --git a/apps/faultmanagement/app/features.xml b/apps/faultmanagement/app/features.xml
deleted file mode 100644
index 313e46d..0000000
--- a/apps/faultmanagement/app/features.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <feature>onos-drivers-default</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-faultmanagement-fmmgr/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-faultmanagement-fmweb/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-faultmanagement-fmgui/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-faultmanagement-fmcli/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/gangliametrics/features.xml b/apps/gangliametrics/features.xml
deleted file mode 100644
index 07a5d42..0000000
--- a/apps/gangliametrics/features.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-gangliametrics/${project.version}</bundle>
-        <bundle>mvn:io.dropwizard.metrics/metrics-core/3.1.2</bundle>
-        <bundle>mvn:io.dropwizard.metrics/metrics-ganglia/3.1.2</bundle>
-        <bundle>mvn:info.ganglia.gmetric4j/gmetric4j/1.0.10</bundle>
-        <bundle>mvn:org.acplt.remotetea/remotetea-oncrpc/1.1.3</bundle>
-    </feature>
-</features>
diff --git a/apps/gluon/features.xml b/apps/gluon/features.xml
deleted file mode 100644
index ae6bf2b..0000000
--- a/apps/gluon/features.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-    </feature>
-</features>
diff --git a/apps/graphitemetrics/features.xml b/apps/graphitemetrics/features.xml
deleted file mode 100644
index 12a9934..0000000
--- a/apps/graphitemetrics/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-graphitemetrics/${project.version}</bundle>
-        <bundle>mvn:io.dropwizard.metrics/metrics-core/3.2.2</bundle>
-        <bundle>mvn:io.dropwizard.metrics/metrics-graphite/3.2.2</bundle>
-    </feature>
-</features>
diff --git a/apps/influxdbmetrics/features.xml b/apps/influxdbmetrics/features.xml
deleted file mode 100644
index 5cd8850..0000000
--- a/apps/influxdbmetrics/features.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-influxdbmetrics/${project.version}</bundle>
-        <bundle>wrap:mvn:com.izettle/metrics-influxdb/1.1.1$Bundle-SymbolicName=metrics-influxdb&amp;Bundle-Version=1.1.1</bundle>
-        <bundle>mvn:commons-codec/commons-codec/1.10</bundle>
-        <bundle>wrap:mvn:org.influxdb/influxdb-java/2.1$Bundle-SymbolicName=influxdb-java&amp;Bundle-Version=2.1</bundle>
-        <bundle>wrap:mvn:com.squareup.retrofit/retrofit/1.9.0$Bundle-SymbolicName=retrofit&amp;Bundle-Version=1.9.0</bundle>
-        <bundle>wrap:mvn:com.squareup.okhttp/okhttp/2.4.0$Bundle-SymbolicName=okhttp&amp;Bundle-Version=2.4.0</bundle>
-        <bundle>wrap:mvn:com.squareup.okio/okio/1.4.0$Bundle-SymbolicName=okio&amp;Bundle-Version=1.4.0</bundle>
-        <bundle>mvn:com.google.code.gson/gson/2.3.1</bundle>
-    </feature>
-</features>
diff --git a/apps/kafka-integration/app/app.xml b/apps/kafka-integration/app/app.xml
deleted file mode 100644
index 1cfbf18..0000000
--- a/apps/kafka-integration/app/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.kafkaintegration" origin="Calix" version="${project.version}"
-     category="Utility" url="http://onosproject.org" title="Kafka Integration Application"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}" apps="org.onosproject.incubator.protobuf">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-kafka-integration-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-kafka-integration-app/${project.version}</artifact>
-    <artifact>mvn:org.apache.servicemix.bundles/org.apache.servicemix.bundles.kafka-clients/0.8.2.2_1</artifact>
-</app>
diff --git a/apps/kafka-integration/app/features.xml b/apps/kafka-integration/app/features.xml
deleted file mode 100644
index 924d868..0000000
--- a/apps/kafka-integration/app/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-kafka-integration-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-kafka-integration-app/${project.version}</bundle>
-        <bundle>mvn:org.apache.servicemix.bundles/org.apache.servicemix.bundles.kafka-clients/0.8.2.2_1</bundle>
-    </feature>
-</features>
diff --git a/apps/mappingmanagement/app/app.xml b/apps/mappingmanagement/app/app.xml
deleted file mode 100644
index 78ac759..0000000
--- a/apps/mappingmanagement/app/app.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.mapping" origin="ON.Lab" version="${project.version}"
-     category="Monitoring" url="https://onosproject.org/" title="Mapping Management App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-mappingmanagement-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-mappingmanagement-mgr/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-mappingmanagement-web/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-mappingmanagement-cli/${project.version}</artifact>
-</app>
diff --git a/apps/mappingmanagement/app/features.xml b/apps/mappingmanagement/app/features.xml
deleted file mode 100644
index a3deefd..0000000
--- a/apps/mappingmanagement/app/features.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-mappingmanagement-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-mappingmanagement-mgr/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-mappingmanagement-web/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-mappingmanagement-cli/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/mcast/app/app.xml b/apps/mcast/app/app.xml
deleted file mode 100644
index ff42633..0000000
--- a/apps/mcast/app/app.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.mcast" origin="ONF" version="${project.version}"
-     category="Traffic Engineering" url="" title="Multicast App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-mcast-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-mcast-impl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-mcast-web/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-mcast-cli/${project.version}</artifact>
-</app>
diff --git a/apps/mcast/app/features.xml b/apps/mcast/app/features.xml
deleted file mode 100644
index 5f69b9b..0000000
--- a/apps/mcast/app/features.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <feature>onos-drivers-default</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-mcast-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-mcast-impl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-mcast-web/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-mcast-cli/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/network-troubleshoot/app/app.xml b/apps/network-troubleshoot/app/app.xml
deleted file mode 100644
index eb60a81..0000000
--- a/apps/network-troubleshoot/app/app.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.fnl.Network.Troubleshoot" category="Core" version="${project.version}"
-     title="Network TroubleShoot SubSystem"
-     originUrl="http://www.bupt.edu.cn" origin="FNLab, BUPT"
-     features="${project.artifactId}"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     url="https://wiki.onosproject.org/display/ONOS/Network+TroubleShooting+Module">
-
-    <description>${project.description}</description>
-
-    <artifact>mvn:${project.groupId}/onos-network-troubleshoot-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-network-troubleshoot-core/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-network-troubleshoot-cli/${project.version}</artifact>
-
-</app>
diff --git a/apps/network-troubleshoot/app/features.xml b/apps/network-troubleshoot/app/features.xml
deleted file mode 100644
index b0026e8..0000000
--- a/apps/network-troubleshoot/app/features.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0"
-          name="${project.artifactId}-${project.version}">
-
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-
-        <bundle>mvn:${project.groupId}/onos-network-troubleshoot-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-network-troubleshoot-core/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-network-troubleshoot-cli/${project.version}</bundle>
-
-    </feature>
-
-</features>
diff --git a/apps/openstacknetworking/app/app.xml b/apps/openstacknetworking/app/app.xml
deleted file mode 100644
index 781a92c..0000000
--- a/apps/openstacknetworking/app/app.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.openstacknetworking" origin="Open Networking Foundation" version="${project.version}"
-     category="Utility" url="https://wiki.onosproject.org/display/ONOS/SONA%3A+DC+Network+Virtualization"
-     title="OpenStack Networking App" features="${project.artifactId}" apps="org.onosproject.openstacknode"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-openstacknetworking-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-openstacknetworking-app/${project.version}</artifact>
-</app>
diff --git a/apps/openstacknetworking/app/features.xml b/apps/openstacknetworking/app/features.xml
deleted file mode 100644
index 51cb23f..0000000
--- a/apps/openstacknetworking/app/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-openstacknetworking-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-openstacknetworking-app/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/openstacknode/app/app.xml b/apps/openstacknode/app/app.xml
deleted file mode 100644
index 6b78b5e..0000000
--- a/apps/openstacknode/app/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.openstacknode" origin="Open Networking Foundation" version="${project.version}"
-     category="Utility" url="https://wiki.onosproject.org/display/ONOS/SONA%3A+DC+Network+Virtualization"
-     title="OpenStack Node App" features="${project.artifactId}"
-     apps="org.onosproject.ovsdb-base,org.onosproject.drivers.ovsdb"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-openstacknode-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-openstacknode-app/${project.version}</artifact>
-</app>
diff --git a/apps/openstacknode/app/features.xml b/apps/openstacknode/app/features.xml
deleted file mode 100644
index fdd76cc..0000000
--- a/apps/openstacknode/app/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-openstacknode-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-openstacknode-app/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/openstacktelemetry/app/app.xml b/apps/openstacktelemetry/app/app.xml
deleted file mode 100644
index 75a5b3f..0000000
--- a/apps/openstacktelemetry/app/app.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.openstacktelemetry" origin="Open Networking Foundation"
-     version="${project.version}" category="Utility" title="OpenStack Telemetry App"
-     features="${project.artifactId}" apps="org.onosproject.openstacknetworking"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-openstacktelemetry-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-openstacktelemetry-app/${project.version}</artifact>
-</app>
diff --git a/apps/openstacktelemetry/app/features.xml b/apps/openstacktelemetry/app/features.xml
deleted file mode 100644
index 0949089..0000000
--- a/apps/openstacktelemetry/app/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-openstacktelemetry-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-openstacktelemetry-app/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/openstacktroubleshoot/app/app.xml b/apps/openstacktroubleshoot/app/app.xml
deleted file mode 100644
index 8d219be..0000000
--- a/apps/openstacktroubleshoot/app/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.openstacktroubleshoot" origin="Open Networking Foundation" version="${project.version}"
-     category="Integration" url="https://wiki.onosproject.org/display/ONOS/SONA%3A+DC+Network+Virtualization"
-     title="OpenStack Troubleshoot App" features="${project.artifactId}"
-     apps="org.onosproject.openstacknetworking"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-openstacktroubleshoot-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-openstacktroubleshoot-app/${project.version}</artifact>
-</app>
diff --git a/apps/openstacktroubleshoot/app/features.xml b/apps/openstacktroubleshoot/app/features.xml
deleted file mode 100644
index cb56ba4..0000000
--- a/apps/openstacktroubleshoot/app/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-openstacktroubleshoot-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-openstacktroubleshoot-app/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/openstackvtap/app/app.xml b/apps/openstackvtap/app/app.xml
deleted file mode 100644
index b077858..0000000
--- a/apps/openstackvtap/app/app.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.openstackvtap" origin="Open Networking Foundation"
-     version="${project.version}" category="Utility" title="Openstack Vtap App"
-     features="${project.artifactId}" apps="org.onosproject.openstacknetworking"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-openstackvtap-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-openstackvtap-app/${project.version}</artifact>
-</app>
diff --git a/apps/openstackvtap/app/features.xml b/apps/openstackvtap/app/features.xml
deleted file mode 100644
index 0e8d5c6..0000000
--- a/apps/openstackvtap/app/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-openstackvtap-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-openstackvtap-app/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/optical-model/features.xml b/apps/optical-model/features.xml
deleted file mode 100644
index 63bbdaa..0000000
--- a/apps/optical-model/features.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.1" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/reactive-routing/features.xml b/apps/reactive-routing/features.xml
deleted file mode 100644
index 2158a68..0000000
--- a/apps/reactive-routing/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="onos-apps-reactive-routing" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-reactive-routing/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-routing-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-routing-common/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/restconf/app/app.xml b/apps/restconf/app/app.xml
deleted file mode 100644
index ca7f79b..0000000
--- a/apps/restconf/app/app.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.restconf" origin="ON.Lab" version="${project.version}"
-     category="Utility" url="http://onosproject.org" title="RESTCONF Service Module App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}" >
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-restconf-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-restconf-restconfmgr/${project.version}</artifact>
-</app>
diff --git a/apps/restconf/app/features.xml b/apps/restconf/app/features.xml
deleted file mode 100644
index cf84a3e..0000000
--- a/apps/restconf/app/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-restconf-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-restconf-restconfmgr/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/route-service/app/app.xml b/apps/route-service/app/app.xml
deleted file mode 100644
index 3ed0537..0000000
--- a/apps/route-service/app/app.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.routeservice" origin="Open Networking Foundation" version="${project.version}"
-     category="Utility" url="http://onosproject.org" title="Route Service App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-route-service-api/${project.version}</artifact>
-</app>
diff --git a/apps/route-service/app/features.xml b/apps/route-service/app/features.xml
deleted file mode 100644
index 165bee4..0000000
--- a/apps/route-service/app/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-route-service-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-route-service/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/sdnip/app.xml b/apps/sdnip/app.xml
deleted file mode 100644
index 24ce985..0000000
--- a/apps/sdnip/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.sdnip" origin="Open Networking Foundation" version="${project.version}"
-     category="Traffic Steering" url="http://onosproject.org" title="SDN-IP App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}" apps="intentsynchronizer">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-routing-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-routing-common/${project.version}</artifact>
-</app>
diff --git a/apps/sdnip/features.xml b/apps/sdnip/features.xml
deleted file mode 100644
index 4304447..0000000
--- a/apps/sdnip/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="onos-apps-sdnip" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-sdnip/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-routing-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-routing-common/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/simplefabric/app/app.xml b/apps/simplefabric/app/app.xml
deleted file mode 100644
index 3898661..0000000
--- a/apps/simplefabric/app/app.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.simplefabric" origin="Open Networking Foundation" version="${project.version}"
-     category="Traffic Steering" url="http://onosproject.org" title="Simple Leaf-Spine Network App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}" apps="org.onosproject.openflow-base,org.onosproject.lldpprovider,org.onosproject.hostprovider">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-</app>
diff --git a/apps/simplefabric/app/features.xml b/apps/simplefabric/app/features.xml
deleted file mode 100644
index c9ac9f5..0000000
--- a/apps/simplefabric/app/features.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="onos-apps-simplefabric" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-simplefabric/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/tenbi/topology/app.xml b/apps/tenbi/topology/app.xml
deleted file mode 100644
index 84d3a60..0000000
--- a/apps/tenbi/topology/app.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015 Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.tenbi.topology" origin="HUAWEI" version="${project.version}"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-tenbi-yangmodel/${project.version}</artifact>
-</app>
-
diff --git a/apps/tenbi/topology/features.xml b/apps/tenbi/topology/features.xml
deleted file mode 100644
index cf4a7f5..0000000
--- a/apps/tenbi/topology/features.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015 Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <repository>mvn:${project.groupId}/onos-apps-tenbi-yangmodel/${project.version}/xml/features</repository>
-    <feature name="${project.artifactId}" version="${project.version}" description="${project.description}">
-        <feature>onos-api</feature>
-        <feature>onos-apps-tenbi-yangmodel</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-tetopology/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-yms-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-tenbi-utils/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/tenbi/tunnel/app.xml b/apps/tenbi/tunnel/app.xml
deleted file mode 100644
index 8df84d4..0000000
--- a/apps/tenbi/tunnel/app.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ /*
-  ~  * Copyright 2016-present Open Networking Foundation
-  ~  *
-  ~  * 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.
-  ~  */
-  -->
-<app name="org.onosproject.tenbi.tunnel" origin="HUAWEI" version="${project.version}"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-tenbi-yangmodel/${project.version}</artifact>
-</app>
-
diff --git a/apps/tenbi/tunnel/features.xml b/apps/tenbi/tunnel/features.xml
deleted file mode 100644
index d8fa1b4..0000000
--- a/apps/tenbi/tunnel/features.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ /*
-  ~  * Copyright 2016-present Open Networking Foundation
-  ~  *
-  ~  * 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.
-  ~  */
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <repository>mvn:${project.groupId}/onos-apps-tenbi-yangmodel/${project.version}/xml/features</repository>
-    <feature name="${project.artifactId}" version="${project.version}" description="${project.description}">
-        <feature>onos-api</feature>
-        <feature>onos-apps-tenbi-yangmodel</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-tetopology-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-yms-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-tetunnel-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-tenbi-utils/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/tenbi/yangmodel/features.xml b/apps/tenbi/yangmodel/features.xml
deleted file mode 100644
index deb89c3..0000000
--- a/apps/tenbi/yangmodel/features.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015 Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="@PROJECT-ARTIFACTID-@ONOS-VERSION" >
-    <feature name="@PROJECT-ARTIFACTID" version="@ONOS-VERSION"
-             description="@PROJECT-DESCRIPTION" >
-        <bundle>mvn:@PROJECT-GROUPID/@PROJECT-ARTIFACTID/@ONOS-VERSION</bundle>
-    </feature>
-</features>
\ No newline at end of file
diff --git a/apps/tetopology/app/app.xml b/apps/tetopology/app/app.xml
deleted file mode 100644
index 40f8da6..0000000
--- a/apps/tetopology/app/app.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015 Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.tetopology" origin="HUAWEI" version="${project.version}"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-</app>
-
diff --git a/apps/tetopology/app/features.xml b/apps/tetopology/app/features.xml
deleted file mode 100644
index 41af7ce..0000000
--- a/apps/tetopology/app/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015 Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-tetopology-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-tetopology/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/tetunnel/app/app.xml b/apps/tetunnel/app/app.xml
deleted file mode 100644
index 6f0ab72..0000000
--- a/apps/tetunnel/app/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.tetunnel" origin="HUAWEI" version="${project.version}"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}"
-     apps="org.onosproject.tetopology">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-tetunnel-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-</app>
\ No newline at end of file
diff --git a/apps/tetunnel/app/features.xml b/apps/tetunnel/app/features.xml
deleted file mode 100644
index 545cdfd..0000000
--- a/apps/tetunnel/app/features.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-tetopology-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-tetunnel-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-    </feature>
-</features>
\ No newline at end of file
diff --git a/apps/virtualbng/features.xml b/apps/virtualbng/features.xml
deleted file mode 100644
index 88d6934..0000000
--- a/apps/virtualbng/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <bundle>mvn:org.glassfish.jersey.core/jersey-client/2.26</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-virtualbng/${project.version}</bundle>
-        <feature>onos-thirdparty-web</feature>
-    </feature>
-</features>
diff --git a/apps/vtn/app/app.xml b/apps/vtn/app/app.xml
deleted file mode 100644
index 270e274..0000000
--- a/apps/vtn/app/app.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.vtn" origin="ON.Lab" version="${project.version}"
-     category="Utility" url="http://onosproject.org" title="OPNFV App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-vtn-vtnmgr/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-vtn-sfcmgr/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-vtn-vtnweb/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-vtn-vtnrsc/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-vtn-sfcweb/${project.version}</artifact>
-</app>
diff --git a/apps/vtn/app/features.xml b/apps/vtn/app/features.xml
deleted file mode 100644
index 374102c..0000000
--- a/apps/vtn/app/features.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <feature>onos-drivers-default</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-vtn-vtnmgr/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-vtn-sfcmgr/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-vtn-vtnweb/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-vtn-vtnrsc/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-vtn-sfcweb/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/apps/yms/app/app.xml b/apps/yms/app/app.xml
deleted file mode 100644
index bedcf30..0000000
--- a/apps/yms/app/app.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.yms" origin="ON.Lab" version="${project.version}"
-     category="Utility" url="http://onosproject.org" title="YMS App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/${project.artifactId}/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-yms-api/${project.version}</artifact>
-</app>
diff --git a/apps/yms/app/features.xml b/apps/yms/app/features.xml
deleted file mode 100644
index ae1e094..0000000
--- a/apps/yms/app/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-yms-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-        <bundle dependency="true">mvn:org.apache.servicemix.bundles/org.apache.servicemix.bundles.dom4j/1.6.1_5</bundle>
-    </feature>
-</features>
diff --git a/drivers/arista/features.xml b/drivers/arista/features.xml
deleted file mode 100644
index 263d488..0000000
--- a/drivers/arista/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-drivers-utilities/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/bmv2/features.xml b/drivers/bmv2/features.xml
deleted file mode 100644
index 7d851a1..0000000
--- a/drivers/bmv2/features.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0"
-          name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>
-            mvn:${project.groupId}/${project.artifactId}/${project.version}
-        </bundle>
-
-    </feature>
-</features>
diff --git a/drivers/ciena/c5162/features.xml b/drivers/ciena/c5162/features.xml
deleted file mode 100644
index 1e78782..0000000
--- a/drivers/ciena/c5162/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-drivers-utilities/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-drivers-netconf/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/ciena/c5170/features.xml b/drivers/ciena/c5170/features.xml
deleted file mode 100644
index 1e78782..0000000
--- a/drivers/ciena/c5170/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-drivers-utilities/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-drivers-netconf/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/ciena/waveserver/features.xml b/drivers/ciena/waveserver/features.xml
deleted file mode 100644
index 6893131..0000000
--- a/drivers/ciena/waveserver/features.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-restsb-api/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-drivers-utilities/${project.version}</bundle>
-    </feature>
-</features>
\ No newline at end of file
diff --git a/drivers/cisco/netconf/features.xml b/drivers/cisco/netconf/features.xml
deleted file mode 100644
index 9d4a490..0000000
--- a/drivers/cisco/netconf/features.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-drivers-netconf/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-drivers-utilities/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-netconf-api/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/cisco/rest/features.xml b/drivers/cisco/rest/features.xml
deleted file mode 100644
index 2c8372b..0000000
--- a/drivers/cisco/rest/features.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-drivers-utilities/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-restsb-api/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/default/features.xml b/drivers/default/features.xml
deleted file mode 100644
index a382ca9..0000000
--- a/drivers/default/features.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-        <bundle>mvn:org.onosproject/openflowj/3.2.0.onos</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-openflow-api/${project.version}</bundle>
-
-    </feature>
-</features>
diff --git a/drivers/fujitsu/features.xml b/drivers/fujitsu/features.xml
deleted file mode 100644
index 5f2b7c4..0000000
--- a/drivers/fujitsu/features.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-drivers-utilities/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-protocols-netconf-api/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/gnmi/features.xml b/drivers/gnmi/features.xml
deleted file mode 100644
index 448f07a..0000000
--- a/drivers/gnmi/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-    </feature>
-</features>
diff --git a/drivers/hp/features.xml b/drivers/hp/features.xml
deleted file mode 100644
index 1e69ff0..0000000
--- a/drivers/hp/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-drivers-utilities/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/juniper/features.xml b/drivers/juniper/features.xml
deleted file mode 100644
index c6e4911..0000000
--- a/drivers/juniper/features.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-<!--
-  ~ Copyright 2016 Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0"
-          name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>
-            mvn:${project.groupId}/${project.artifactId}/${project.version}
-        </bundle>
-
-        <bundle>
-            mvn:${project.groupId}/onos-drivers-utilities/${project.version}
-        </bundle>
-
-        <bundle>mvn:${project.groupId}/onos-protocols-netconf-api/${project.version}
-        </bundle>
-    </feature>
-</features>
diff --git a/drivers/lisp/features.xml b/drivers/lisp/features.xml
deleted file mode 100644
index 9aa99aa..0000000
--- a/drivers/lisp/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-lisp-api/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/lumentum/features.xml b/drivers/lumentum/features.xml
deleted file mode 100644
index 43a8f41..0000000
--- a/drivers/lumentum/features.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-        <bundle>mvn:org.apache.servicemix.bundles/org.apache.servicemix.bundles.snmp4j/2.3.4_1</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-protocols-snmp-api/${project.version}</bundle>
-
-    </feature>
-</features>
diff --git a/drivers/netconf/features.xml b/drivers/netconf/features.xml
deleted file mode 100644
index 5f2b7c4..0000000
--- a/drivers/netconf/features.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-drivers-utilities/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-protocols-netconf-api/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/oplink/features.xml b/drivers/oplink/features.xml
deleted file mode 100644
index a716991..0000000
--- a/drivers/oplink/features.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-<!--
-  ~ Copyright 2016 Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-drivers-utilities/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-protocols-netconf-api/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/ovsdb/features.xml b/drivers/ovsdb/features.xml
deleted file mode 100644
index ea1932d..0000000
--- a/drivers/ovsdb/features.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-protocols-ovsdb-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-ovsdb-rfc/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/drivers/p4runtime/features.xml b/drivers/p4runtime/features.xml
deleted file mode 100644
index 448f07a..0000000
--- a/drivers/p4runtime/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-
-    </feature>
-</features>
diff --git a/drivers/utilities/features.xml b/drivers/utilities/features.xml
deleted file mode 100644
index 9c81ada..0000000
--- a/drivers/utilities/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/incubator/grpc/features.xml b/incubator/grpc/features.xml
deleted file mode 100644
index 9517edf..0000000
--- a/incubator/grpc/features.xml
+++ /dev/null
@@ -1,51 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature version="${project.version}">grpc</feature>
-
-        <bundle>mvn:com.google.protobuf/protobuf-java/3.0.0</bundle>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-    </feature>
-
-    <feature name="grpc-netty" version="${project.version}"
-             description="gRPC Netty dependencies">
-        <bundle>mvn:io.netty/netty-common/${grpc.netty.version}</bundle>
-        <bundle>mvn:io.netty/netty-buffer/${grpc.netty.version}</bundle>
-        <bundle>mvn:io.netty/netty-transport/${grpc.netty.version}</bundle>
-        <bundle>mvn:io.netty/netty-handler/${grpc.netty.version}</bundle>
-        <bundle>mvn:io.netty/netty-codec/${grpc.netty.version}</bundle>
-        <bundle>mvn:io.netty/netty-codec-http/${grpc.netty.version}</bundle>
-        <bundle>mvn:io.netty/netty-codec-http2/${grpc.netty.version}</bundle>
-        <bundle>mvn:io.netty/netty-resolver/${grpc.netty.version}</bundle>
-    </feature>
-
-    <feature name="grpc" version="${project.version}" description="gRPC dependencies">
-        <feature version="${project.version}">grpc-netty</feature>
-        <bundle>wrap:mvn:com.google.auth/google-auth-library-credentials/${google.auth.version}$Bundle-SymbolicName=com.google.auth.google-auth-library-credentials&amp;Bundle-Version=${google.auth.version}</bundle>
-        <bundle>wrap:mvn:com.google.auth/google-auth-library-oauth2-http/${google.auth.version}$Bundle-SymbolicName=com.google.auth.google-auth-library-oauth2-http&amp;Bundle-Version=${google.auth.version}</bundle>
-        <!-- Export for io.grpc.internal required for DnsNameResolverProvider -->
-        <bundle>wrap:mvn:io.grpc/grpc-core/${grpc.version}$Bundle-SymbolicName=io.grpc.grpc-core&amp;Bundle-Version=${grpc.package.version}&amp;Export-Package=*;version=${grpc.package.version},io.grpc.internal;version=${grpc.package.version}&amp;</bundle>
-        <bundle>wrap:mvn:io.grpc/grpc-protobuf-lite/${grpc.version}$Bundle-SymbolicName=io.grpc.grpc-protobuf-lite&amp;Bundle-Version=${grpc.package.version}&amp;</bundle>
-        <bundle>wrap:mvn:io.grpc/grpc-protobuf/${grpc.version}$Bundle-SymbolicName=io.grpc.grpc-protobuf&amp;Bundle-Version=${grpc.package.version}&amp;</bundle>
-        <bundle>wrap:mvn:io.grpc/grpc-stub/${grpc.version}$Bundle-SymbolicName=io.grpc.grpc-stub&amp;Bundle-Version=${grpc.package.version}&amp;</bundle>
-        <bundle>wrap:mvn:io.grpc/grpc-netty/${grpc.version}$Bundle-SymbolicName=io.grpc.grpc-netty&amp;Bundle-Version=${grpc.package.version}&amp;Import-Package=io.netty.*;version=${grpc.netty.package.version},*</bundle>
-        <bundle>wrap:mvn:io.grpc/grpc-auth/${grpc.version}$Bundle-SymbolicName=io.grpc.grpc-auth&amp;Bundle-Version=${grpc.package.version}&amp;Import-Package=javax.net.ssl,*</bundle>
-    </feature>
-
-</features>
diff --git a/incubator/protobuf/features.xml b/incubator/protobuf/features.xml
deleted file mode 100644
index 881b2dc..0000000
--- a/incubator/protobuf/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.1" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:com.google.protobuf/protobuf-java/${protobuf.version}</bundle>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/incubator/rpc-grpc/features.xml b/incubator/rpc-grpc/features.xml
deleted file mode 100644
index 9ada9c6..0000000
--- a/incubator/rpc-grpc/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.1" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature version="${project.version}">onos-api</feature>
-
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/incubator/rpc-nb/features.xml b/incubator/rpc-nb/features.xml
deleted file mode 100644
index 0a03ccb..0000000
--- a/incubator/rpc-nb/features.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <feature>onos-incubator-grpc</feature>
-
-        <bundle>mvn:${project.groupId}/onos-incubator-protobuf-nb/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/protocols/restconf/server/app/app.xml b/protocols/restconf/server/app/app.xml
deleted file mode 100644
index 3932591..0000000
--- a/protocols/restconf/server/app/app.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.protocols.restconfserver" origin="ON.Lab" version="${project.version}"
-     category="Utility" url="http://onosproject.org" title="RESTCONF Service Module App"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}" >
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-restconf-server-rpp/${project.version}</artifact>
-</app>
diff --git a/protocols/restconf/server/app/features.xml b/protocols/restconf/server/app/features.xml
deleted file mode 100644
index 9b3f1d7..0000000
--- a/protocols/restconf/server/app/features.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-restconf-server-rpp/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/providers/bgp/app/app.xml b/providers/bgp/app/app.xml
deleted file mode 100644
index 139805c..0000000
--- a/providers/bgp/app/app.xml
+++ /dev/null
@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.bgp" origin="ON.Lab" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="BGP Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-protocols-bgp-bgpio/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-protocols-bgp-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-protocols-bgp-ctl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-server-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-bgp-topology/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-bgp-cfg/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-bgp-cli/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcepio/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-pcep-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-server-impl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-provider-topology/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-provider-tunnel/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-pce-app/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-pce-pceweb/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-pce-pcerest/${project.version}</artifact>
-</app>
diff --git a/providers/bgp/app/features.xml b/providers/bgp/app/features.xml
deleted file mode 100644
index 18622fb..0000000
--- a/providers/bgp/app/features.xml
+++ /dev/null
@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-protocols-bgp-bgpio/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-bgp-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-bgp-ctl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-server-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-bgp-topology/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-bgp-cli/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-bgp-cfg/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcepio/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-pcep-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-server-impl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-provider-topology/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-provider-tunnel/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-pce-app/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-pce-pceweb/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-pce-pcerest/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/providers/bgpcep/app/app.xml b/providers/bgpcep/app/app.xml
deleted file mode 100644
index 28afaad..0000000
--- a/providers/bgpcep/app/app.xml
+++ /dev/null
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.bgpcep" origin="ON.Lab" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="BGP PCEP Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-protocols-bgp-bgpio/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-protocols-bgp-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-protocols-bgp-ctl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcepio/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-pcep-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-server-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-bgp-topology/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-bgp-cfg/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-server-impl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-provider-topology/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-provider-tunnel/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-bgpcep-flow/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-pce-app/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-pce-pceweb/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-pce-pcerest/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-pce-bandwidthmgmt/${project.version}</artifact>
-</app>
diff --git a/providers/bgpcep/app/features.xml b/providers/bgpcep/app/features.xml
deleted file mode 100644
index 378205b..0000000
--- a/providers/bgpcep/app/features.xml
+++ /dev/null
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-protocols-bgp-bgpio/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-bgp-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-bgp-ctl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-server-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-bgp-topology/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-bgp-cfg/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcepio/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-pcep-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-server-impl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-provider-topology/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-provider-tunnel/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-pce-app/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-pce-pceweb/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-bgpcep-flow/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-pce-pcerest/${project.version}</bundle>
-	<bundle>mvn:${project.groupId}/onos-apps-pce-bandwidthmgmt/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/providers/general/app/app.xml b/providers/general/app/app.xml
deleted file mode 100644
index 3e9c4e9..0000000
--- a/providers/general/app/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.generaldeviceprovider" origin="ON.Lab" version="${project.version}"
-     category="Provider" url="https://wiki.onosproject.org/" title="General Device Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-
-    <artifact>mvn:${project.groupId}/onos-providers-general-device/${project.version}</artifact>
-
-</app>
diff --git a/providers/general/app/features.xml b/providers/general/app/features.xml
deleted file mode 100644
index 45ff1f0..0000000
--- a/providers/general/app/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-
-        <bundle>mvn:${project.groupId}/onos-providers-general-device/${project.version}</bundle>
-    </feature>
-</features>
-
diff --git a/providers/ietfte/app/app.xml b/providers/ietfte/app/app.xml
deleted file mode 100644
index ecda3bf..0000000
--- a/providers/ietfte/app/app.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.teprovider" origin="HUAWEI" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="RESTCONF TE Topology Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-restconf-client-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-restconf-client-ctl/${project.version}</artifact>
-
-    <artifact>mvn:${project.groupId}/onos-ietfte-provider-utils/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-ietfte-provider-topology/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-ietfte-provider-tunnel/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-apps-tenbi-yangmodel/${project.version}</artifact>
-</app>
diff --git a/providers/ietfte/app/features.xml b/providers/ietfte/app/features.xml
deleted file mode 100644
index 21d17eb..0000000
--- a/providers/ietfte/app/features.xml
+++ /dev/null
@@ -1,41 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <repository>mvn:${project.groupId}/onos-apps-tenbi-yangmodel/${project.version}/xml/features</repository>
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <feature>onos-apps-tenbi-yangmodel</feature>
-        <bundle>mvn:${project.groupId}/onos-restsb-api/${project.version}</bundle>
-        <bundle>mvn:org.apache.httpcomponents/httpclient-osgi/4.5.1</bundle>
-        <bundle>mvn:org.apache.httpcomponents/httpcore-osgi/4.4.4</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-restconf-client-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-restconf-client-ctl/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-apps-tetunnel-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-tetopology/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-yms-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-tenbi-utils/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-restconf-server-utils/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-ietfte-provider-utils/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-ietfte-provider-topology/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-ietfte-provider-tunnel/${project.version}</bundle>
-    </feature>
-</features>
-
diff --git a/providers/isis/app/app.xml b/providers/isis/app/app.xml
deleted file mode 100644
index f3441e3..0000000
--- a/providers/isis/app/app.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.isis" origin="ON.Lab" version="${project.version}"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-isis-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-isis-isisio/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-isis-ctl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-isis-provider-topology/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-isis-provider-cfg/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-isis-provider-cli/${project.version}</artifact>
-</app>
\ No newline at end of file
diff --git a/providers/isis/app/features.xml b/providers/isis/app/features.xml
deleted file mode 100644
index daacf34..0000000
--- a/providers/isis/app/features.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-isis-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-isis-isisio/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-isis-ctl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-isis-provider-topology/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-isis-provider-cfg/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-isis-provider-cli/${project.version}</bundle>
-    </feature>
-</features>
\ No newline at end of file
diff --git a/providers/link/app.xml b/providers/link/app.xml
deleted file mode 100644
index 0541b17..0000000
--- a/providers/link/app.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.linkdiscovery" origin="acino.eu" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="ONOS link discovery provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-linkdiscovery-provider/${project.version}</artifact>
-</app>
diff --git a/providers/link/features.xml b/providers/link/features.xml
deleted file mode 100644
index 80b95b7..0000000
--- a/providers/link/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  --><features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-linkdiscovery-provider/${project.version}</bundle>
-    </feature>
-</features>
-
diff --git a/providers/lisp/app/app.xml b/providers/lisp/app/app.xml
deleted file mode 100644
index 884b070..0000000
--- a/providers/lisp/app/app.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.lisp" origin="ON.Lab" version="${project.version}"
-     category="Provider" title="LISP Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-lisp-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-lisp-ctl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-lisp-msg/${project.version}</artifact>
-
-    <artifact>mvn:${project.groupId}/onos-lisp-provider-device/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-lisp-provider-mapping/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-lisp-provider-message/${project.version}</artifact>
-</app>
diff --git a/providers/lisp/app/features.xml b/providers/lisp/app/features.xml
deleted file mode 100644
index 7a925ca..0000000
--- a/providers/lisp/app/features.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-lisp-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-lisp-ctl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-lisp-msg/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-lisp-provider-device/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-lisp-provider-mapping/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-lisp-provider-message/${project.version}</bundle>
-    </feature>
-</features>
-
diff --git a/providers/lldp/app.xml b/providers/lldp/app.xml
deleted file mode 100644
index 69a2f39..0000000
--- a/providers/lldp/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.lldpprovider" origin="Open Networking Foundation" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="LLDP Link Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-lldp-provider/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-lldp-provider-common/${project.version}</artifact>
-
-</app>
diff --git a/providers/lldp/features.xml b/providers/lldp/features.xml
deleted file mode 100644
index f62512b..0000000
--- a/providers/lldp/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  --><features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-lldp-provider/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-lldp-provider-common/${project.version}</bundle>
-    </feature>
-</features>
-
diff --git a/providers/netcfglinks/app.xml b/providers/netcfglinks/app.xml
deleted file mode 100644
index 83ebb521..0000000
--- a/providers/netcfglinks/app.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.netcfglinksprovider" origin="Open Networking Foundation" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="Network Config Link Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-netcfg-links-provider/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-lldp-provider-common/${project.version}</artifact>
-
-</app>
diff --git a/providers/netcfglinks/features.xml b/providers/netcfglinks/features.xml
deleted file mode 100644
index d69a34e..0000000
--- a/providers/netcfglinks/features.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-netcfg-links-provider/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-lldp-provider-common/${project.version}</bundle>
-    </feature>
-</features>
-
diff --git a/providers/netconf/app/app.xml b/providers/netconf/app/app.xml
deleted file mode 100644
index 00ce4ff..0000000
--- a/providers/netconf/app/app.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.netconf" origin="ON.Lab" version="${project.version}"
-     category="Provider" url="https://wiki.onosproject.org/display/ONOS/NETCONF" title="NETCONF Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     apps="org.onosproject.faultmanagement"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-protocols-netconf-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-protocols-netconf-ctl/${project.version}</artifact>
-
-    <artifact>mvn:${project.groupId}/onos-netconf-provider-device/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-netconf-provider-alarm/${project.version}</artifact>
-
-</app>
diff --git a/providers/netconf/app/features.xml b/providers/netconf/app/features.xml
deleted file mode 100644
index 84d0c3b..0000000
--- a/providers/netconf/app/features.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:io.netty/netty/3.9.2.Final</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-netconf-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-netconf-ctl/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-netconf-provider-device/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-netconf-provider-alarm/${project.version}</bundle>
-    </feature>
-</features>
-
diff --git a/providers/openflow/base/app.xml b/providers/openflow/base/app.xml
deleted file mode 100644
index a3ae69e..0000000
--- a/providers/openflow/base/app.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.openflow-base" origin="ON.Lab" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="OpenFlow Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}" apps="org.onosproject.optical-model">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-protocols-openflow-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-protocols-openflow-ctl/${project.version}</artifact>
-
-    <artifact>mvn:${project.groupId}/onos-providers-openflow-device/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-openflow-packet/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-openflow-flow/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-openflow-group/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-openflow-meter/${project.version}</artifact>
-</app>
diff --git a/providers/openflow/base/features.xml b/providers/openflow/base/features.xml
deleted file mode 100644
index ff701c8..0000000
--- a/providers/openflow/base/features.xml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:org.onosproject/openflowj/3.2.0.onos</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-openflow-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-openflow-ctl/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-providers-openflow-device/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-openflow-packet/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-openflow-flow/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-openflow-group/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-openflow-meter/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/providers/openflow/message/app.xml b/providers/openflow/message/app.xml
deleted file mode 100644
index dfe4851..0000000
--- a/providers/openflow/message/app.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.openflow-message" origin="Open Networking Foundation" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="Control Message Stats Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-providers-openflow-message/${project.version}</artifact>
-</app>
diff --git a/providers/openflow/message/features.xml b/providers/openflow/message/features.xml
deleted file mode 100644
index d7b42fc..0000000
--- a/providers/openflow/message/features.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-providers-openflow-message/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-apps-cpman-api/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/providers/ospf/app/app.xml b/providers/ospf/app/app.xml
deleted file mode 100644
index e72d79c..0000000
--- a/providers/ospf/app/app.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.ospf" origin="ON.Lab" version="${project.version}"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-ospf-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-ospf-ctl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-ospf-protocol/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-ospf-provider-topology/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-ospf-provider-cfg/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-ospf-provider-cli/${project.version}</artifact>
-</app>
diff --git a/providers/ospf/app/features.xml b/providers/ospf/app/features.xml
deleted file mode 100644
index 0ad3474..0000000
--- a/providers/ospf/app/features.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-ospf-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-ospf-ctl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-ospf-protocol/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-ospf-provider-topology/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-ospf-provider-cfg/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-ospf-provider-cli/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/providers/ovsdb/base/app.xml b/providers/ovsdb/base/app.xml
deleted file mode 100644
index ac46ba2..0000000
--- a/providers/ovsdb/base/app.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.ovsdb-base" origin="ON.Lab" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="OVSDB Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-ovsdb-rfc/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-protocols-ovsdb-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-ovsdb-ctl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-drivers-ovsdb/${project.version}</artifact>
-
-    <artifact>mvn:${project.groupId}/onos-ovsdb-provider-device/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-ovsdb-provider-tunnel/${project.version}</artifact>
-</app>
diff --git a/providers/ovsdb/base/features.xml b/providers/ovsdb/base/features.xml
deleted file mode 100644
index 194bf9f..0000000
--- a/providers/ovsdb/base/features.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:io.netty/netty-common/4.0.23.Final</bundle>
-        <bundle>mvn:io.netty/netty-buffer/4.0.23.Final</bundle>
-        <bundle>mvn:io.netty/netty-transport/4.0.23.Final</bundle>
-        <bundle>mvn:io.netty/netty-handler/4.0.23.Final</bundle>
-        <bundle>mvn:io.netty/netty-codec/4.0.23.Final</bundle>
-        <bundle>mvn:${project.groupId}/onos-ovsdb-rfc/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-ovsdb-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-ovsdb-ctl/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-drivers-ovsdb/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-ovsdb-provider-device/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-ovsdb-provider-tunnel/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/providers/pcep/app/app.xml b/providers/pcep/app/app.xml
deleted file mode 100644
index a5e4594..0000000
--- a/providers/pcep/app/app.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.pcep" origin="ON.Lab" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="PCEP Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-apps-pcep-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcepio/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-server-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-server-impl/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-provider-topology/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-provider-tunnel/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-pcep-provider-cli/${project.version}</artifact>
-</app>
diff --git a/providers/pcep/app/features.xml b/providers/pcep/app/features.xml
deleted file mode 100644
index 08bb24f..0000000
--- a/providers/pcep/app/features.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-apps-pcep-api/${project.version}</bundle>
-    <bundle>mvn:${project.groupId}/onos-pcepio/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-server-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-server-impl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-provider-topology/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-provider-tunnel/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-pcep-provider-cli/${project.version}</bundle>
-    </feature>
-</features>
diff --git a/providers/rest/app/app.xml b/providers/rest/app/app.xml
deleted file mode 100644
index 14b9dc8..0000000
--- a/providers/rest/app/app.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.restsb" origin="ON.Lab" version="${project.version}"
-     category="Provider" url="https://wiki.onosproject.org/display/ONOS/REST" title="REST/SB Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-restsb-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-restsb-ctl/${project.version}</artifact>
-
-    <artifact>mvn:${project.groupId}/onos-restsb-provider-device/${project.version}</artifact>
-
-</app>
diff --git a/providers/rest/app/features.xml b/providers/rest/app/features.xml
deleted file mode 100644
index 2b086fa..0000000
--- a/providers/rest/app/features.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-restsb-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-restsb-ctl/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-restsb-provider-device/${project.version}</bundle>
-
-        <bundle>mvn:org.glassfish.jersey.core/jersey-client/2.25.1</bundle>
-        <bundle>mvn:commons-io/commons-io/2.4</bundle>
-        <bundle>mvn:org.apache.httpcomponents/httpclient-osgi/4.5.1</bundle>
-        <bundle>mvn:org.apache.httpcomponents/httpcore-osgi/4.4.4</bundle>
-    </feature>
-</features>
-
diff --git a/providers/snmp/app/app.xml b/providers/snmp/app/app.xml
deleted file mode 100644
index 7cedcee..0000000
--- a/providers/snmp/app/app.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.snmp" origin="BTI Systems" version="${project.version}"
-     category="Provider" url="http://onosproject.org" title="SNMP Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}" apps="org.onosproject.faultmanagement">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-providers-snmp-device/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-providers-snmp-alarm/${project.version}</artifact>
-
-    <artifact>mvn:${project.groupId}/onos-protocols-snmp-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-protocols-snmp-ctl/${project.version}</artifact>
-
-    <artifact>mvn:org.onosproject/snmp-core/1.3-20161021.1</artifact>
-    <artifact>mvn:org.onosproject/mibbler-mibs-bti7000/1.0-20151221.1</artifact>
-    <artifact>mvn:org.onosproject/mibbler-mibs-net-snmp/1.0-20151221.1</artifact>
-
-</app>
diff --git a/providers/snmp/app/features.xml b/providers/snmp/app/features.xml
deleted file mode 100644
index 88176ed..0000000
--- a/providers/snmp/app/features.xml
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:io.netty/netty/3.9.2.Final</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-snmp-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-protocols-snmp-ctl/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-snmp-device/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-providers-snmp-alarm/${project.version}</bundle>
-
-        <bundle>mvn:org.apache.servicemix.bundles/org.apache.servicemix.bundles.snmp4j/2.3.4_1</bundle>
-        <bundle>mvn:org.onosproject/snmp-core/1.3-20161021.1</bundle>
-        <bundle>mvn:org.onosproject/mibbler-mibs-bti7000/1.0-20151221.1</bundle>
-        <bundle>mvn:org.onosproject/mibbler-mibs-net-snmp/1.0-20151221.1</bundle>
-    </feature>
-</features>
-
diff --git a/providers/tl1/app/app.xml b/providers/tl1/app/app.xml
deleted file mode 100644
index b0ff85a..0000000
--- a/providers/tl1/app/app.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<app name="org.onosproject.tl1" origin="ON.Lab" version="${project.version}"
-     category="Provider" title="TL1 Provider"
-     featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features"
-     features="${project.artifactId}">
-    <description>${project.description}</description>
-    <artifact>mvn:${project.groupId}/onos-tl1-api/${project.version}</artifact>
-    <artifact>mvn:${project.groupId}/onos-tl1-ctl/${project.version}</artifact>
-
-    <artifact>mvn:${project.groupId}/onos-tl1-provider-device/${project.version}</artifact>
-
-</app>
diff --git a/providers/tl1/app/features.xml b/providers/tl1/app/features.xml
deleted file mode 100644
index 6228823..0000000
--- a/providers/tl1/app/features.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}">
-    <feature name="${project.artifactId}" version="${project.version}"
-             description="${project.description}">
-        <feature>onos-api</feature>
-        <bundle>mvn:${project.groupId}/onos-tl1-api/${project.version}</bundle>
-        <bundle>mvn:${project.groupId}/onos-tl1-ctl/${project.version}</bundle>
-
-        <bundle>mvn:${project.groupId}/onos-tl1-provider-device/${project.version}</bundle>
-    </feature>
-</features>
-
