Delete repeat file with share directory

Change-Id: I93ecf179670216cb0b82803048daf22d0cd3b915
Issue-ID: MULTICLOUD-138
Signed-off-by: Huang Haibin <haibin.huang@intel.com>

13 files changed, 0 insertions, 2147 deletions

diff --git a/newton/newton/requests/views/__init__.py b/newton/newton/requests/views/__init__.py
deleted file mode 100644
index afa702d3..00000000
--- a/newton/newton/requests/views/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
diff --git a/newton/newton/requests/views/flavor.py b/newton/newton/requests/views/flavor.py
deleted file mode 100644
index 8db417c8..00000000
--- a/newton/newton/requests/views/flavor.py
+++ /dev/null
@@ -1,346 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-import json
-import traceback
-
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from newton.pub.exceptions import VimDriverNewtonException
-from newton.requests.views.util import VimDriverUtils
-
-logger = logging.getLogger(__name__)
-
-
-class Flavors(APIView):
-    service = {'service_type': 'compute',
-               'interface': 'public'}
-    keys_mapping = [
-        ("project_id", "tenantId"),
-        ("ram", "memory"),
-        ("vcpus", "vcpu"),
-        ("OS-FLV-EXT-DATA:ephemeral", "ephemeral"),
-        ("os-flavor-access:is_public", "isPublic"),
-        ("extra_specs", "extraSpecs"),
-    ]
-
-    def _convert_extra_specs(self, extraSpecs, extra_specs, reverse=False):
-       if reverse == False:
-          #from extraSpecs to extra_specs
-          for spec in extraSpecs:
-              extra_specs[spec['keyName']] = spec['value']
-       else:
-          for k,v in extra_specs.items():
-              spec={}
-              spec['keyName']=k
-              spec['value']=v
-              extraSpecs.append(spec)
-
-    def get(self, request, vimid="", tenantid="", flavorid=""):
-        logger.debug("Flavors--get::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            query = VimDriverUtils.get_query_part(request)
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            resp = self._get_flavor(sess, request, flavorid)
-            content = resp.json()
-
-            if flavorid:
-                flavor = content.pop("flavor", None)
-                extraResp = self._get_flavor_extra_specs(sess, flavor["id"])
-                extraContent = extraResp.json()
-                if extraContent["extra_specs"]:
-                    extraSpecs = []
-                    self._convert_extra_specs(extraSpecs, extraContent["extra_specs"], True)
-                    flavor["extraSpecs"] = extraSpecs
-                VimDriverUtils.replace_key_by_mapping(flavor,
-                                                   self.keys_mapping)
-                content.update(flavor)
-
-            else:
-                wanted = None
-                #check if query contains name="flavorname"
-                if query:
-                    for queryone in query.split('&'):
-                        k,v = queryone.split('=')
-                        if k == "name":
-                            wanted = v
-                            break
-
-                if wanted:
-                   oldFlavors = content.pop("flavors", None)
-                   content["flavors"] = []
-                   for flavor in oldFlavors:
-                       if wanted == flavor["name"]:
-                           content["flavors"].append(flavor)
-
-                #iterate each flavor to get extra_specs
-                for flavor in content["flavors"]:
-                    extraResp = self._get_flavor_extra_specs(sess, flavor["id"])
-                    extraContent = extraResp.json()
-                    if extraContent["extra_specs"]:
-                        extraSpecs = []
-                        self._convert_extra_specs(extraSpecs, extraContent["extra_specs"], True)
-                        flavor["extraSpecs"] = extraSpecs
-                    VimDriverUtils.replace_key_by_mapping(flavor,
-                                                   self.keys_mapping)
-
-            #add extra keys
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-            }
-            content.update(vim_dict)
-
-
-            return Response(data=content, status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def _get_flavor_extra_specs(self, sess, flavorid):
-        if flavorid:
-            logger.debug("Flavors--get_extra_specs::> %s" % flavorid)
-            # prepare request resource to vim instance
-            req_resouce = "/flavors/%s/os-extra_specs" % flavorid
-
-            resp = sess.get(req_resouce, endpoint_filter=self.service)
-            return resp
-        return {}
-
-    def _get_flavor(self, sess, request, flavorid=""):
-        logger.debug("Flavors--get basic")
-        if sess:
-            # prepare request resource to vim instance
-            req_resouce = "/flavors"
-            if flavorid:
-                req_resouce += "/%s" % flavorid
-            else:
-                req_resouce += "/detail"
-
-            query = VimDriverUtils.get_query_part(request)
-            if query:
-                req_resouce += "?%s" % query
-
-            return sess.get(req_resouce, endpoint_filter=self.service)
-        return {}
-
-    def post(self, request, vimid="", tenantid="", flavorid=""):
-        logger.debug("Flavors--post::> %s" % request.data)
-        sess = None
-        resp = None
-        resp_body = None
-        try:
-            # prepare request resource to vim instance
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-
-            #check if the flavor is already created: name or id
-            tmpresp = self._get_flavor(sess, request)
-            content = tmpresp.json()
-            #iterate each flavor to get extra_specs
-            existed = False
-            for flavor in content["flavors"]:
-                if flavor["name"] == request.data["name"]:
-                   existed = True
-                   break
-                elif hasattr(request.data, "id") and flavor["id"] == request.data["id"]:
-                   existed = True
-                   break
-
-            if existed:
-                extraResp = self._get_flavor_extra_specs(sess, flavor["id"])
-                extraContent = extraResp.json()
-                if extraContent["extra_specs"]:
-                    extraSpecs = []
-                    self._convert_extra_specs(extraSpecs, extraContent["extra_specs"], True)
-                    flavor["extraSpecs"] = extraSpecs
-                VimDriverUtils.replace_key_by_mapping(flavor,
-                                               self.keys_mapping)
-                vim_dict = {
-                    "vimName": vim["name"],
-                    "vimId": vim["vimId"],
-                    "tenantId": tenantid,
-                     "returnCode": 0,
-                }
-                flavor.update(vim_dict)
-                return Response(data=flavor, status=tmpresp.status_code)
-
-            extraSpecs = request.data.pop("extraSpecs", None)
-            #create flavor first
-            resp = self._create_flavor(sess, request)
-            if resp.status_code == 202:
-                resp_body = resp.json()["flavor"]
-            else:
-                return resp
-
-
-            flavorid = resp_body['id']
-            if extraSpecs:
-                extra_specs={}
-                self._convert_extra_specs(extraSpecs, extra_specs, False)
-#                logger.debug("extraSpecs:%s" % extraSpecs)
-#                logger.debug("extra_specs:%s" % extra_specs)
-                extraResp = self._create_flavor_extra_specs(sess, extra_specs, flavorid)
-                if extraResp.status_code == 200:
-                    #combine the response body and return
-                    tmpSpecs = []
-                    tmpRespBody = extraResp.json()
-                    self._convert_extra_specs(tmpSpecs, tmpRespBody['extra_specs'], True)
-
-                    resp_body.update({"extraSpecs":tmpSpecs})
-                else:
-                    #rollback
-                    self._delete_flavor(self, request, vimid, tenantid, flavorid)
-                    return extraResp
-
-            VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping)
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-                 "returnCode": 1,
-            }
-            resp_body.update(vim_dict)
-            return Response(data=resp_body, status=resp.status_code)
-        except VimDriverNewtonException as e:
-            if sess and resp and resp.status_code == 200:
-                self._delete_flavor(sess, flavorid)
-
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-
-            if sess and resp and resp.status_code == 200:
-                self._delete_flavor(sess, flavorid)
-
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def _create_flavor(self, sess, request):
-        logger.debug("Flavors--create::> %s" % request.data)
-        # prepare request resource to vim instance
-        req_resouce = "/flavors"
-
-        flavor = request.data
-
-        VimDriverUtils.replace_key_by_mapping(flavor,
-                                              self.keys_mapping, True)
-        req_body = json.JSONEncoder().encode({"flavor": flavor})
-        return sess.post(req_resouce, data=req_body,
-                         endpoint_filter=self.service)
-
-    def _create_flavor_extra_specs(self, sess, extraspecs, flavorid):
-        logger.debug("Flavors extra_specs--post::> %s" % extraspecs)
-        # prepare request resource to vim instance
-        req_resouce = "/flavors"
-        if flavorid:
-            req_resouce += "/%s/os-extra_specs" % flavorid
-        else:
-            raise VimDriverNewtonException(message="VIM newton exception",
-                       content="internal bug in creating flavor extra specs",
-                       status_code=500)
-
-        req_body = json.JSONEncoder().encode({"extra_specs": extraspecs})
-
-        return sess.post(req_resouce, data=req_body,
-                         endpoint_filter=self.service)
-
-    def delete(self, request, vimid="", tenantid="", flavorid=""):
-        logger.debug("Flavors--delete::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-
-            #delete extra specs one by one
-            resp = self._delete_flavor_extra_specs(sess, flavorid)
-
-            #delete flavor
-            resp = self._delete_flavor(sess, flavorid)
-
-            #return results
-            return Response(status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def _delete_flavor_extra_specs(self, sess, flavorid):
-        logger.debug("Flavors--delete extra::> %s" % flavorid)
-
-        #delete extra specs one by one
-        resp = self._get_flavor_extra_specs(sess, flavorid)
-        extra_specs = resp.json()
-        if extra_specs and extra_specs["extra_specs"]:
-            for k, _ in extra_specs["extra_specs"].items():
-                # just try to delete extra spec, but do not care if succeeded
-                self._delete_flavor_one_extra_spec(sess, flavorid, k)
-        return resp
-
-    def _delete_flavor_one_extra_spec(self, sess, flavorid, extra_spec_key):
-        logger.debug("Flavors--delete  1 extra::> %s" % extra_spec_key)
-        # prepare request resource to vim instance
-        try:
-            req_resouce = "/flavors"
-            if flavorid and extra_spec_key:
-                req_resouce += "/%s" % flavorid
-                req_resouce += "/os-extra_specs/%s" % extra_spec_key
-            else:
-                raise VimDriverNewtonException(message="VIM newton exception",
-                       content="internal bug in deleting flavor extra specs: %s" % extra_spec_key,
-                       status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-            return sess.delete(req_resouce, endpoint_filter=self.service)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def _delete_flavor(self, sess, flavorid):
-        logger.debug("Flavors--delete basic::> %s" % flavorid)
-        # prepare request resource to vim instance
-        req_resouce = "/flavors"
-        if flavorid:
-            req_resouce += "/%s" % flavorid
-        else:
-            raise VimDriverNewtonException(message="VIM newton exception",
-                   content="internal bug in deleting flavor",
-                   status_code=500)
-
-        return sess.delete(req_resouce, endpoint_filter=self.service)
diff --git a/newton/newton/requests/views/hosts.py b/newton/newton/requests/views/hosts.py
deleted file mode 100644
index 1b2ed798..00000000
--- a/newton/newton/requests/views/hosts.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-import json
-import traceback
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from newton.pub.exceptions import VimDriverNewtonException
-
-from newton.requests.views.util import VimDriverUtils
-
-logger = logging.getLogger(__name__)
-
-
-class Hosts(APIView):
-    service = {'service_type': 'compute',
-               'interface': 'public'}
-
-    hosts_keys_mapping = [
-        ("host_name", "name"),
-    ]
-    host_keys_mapping = [
-        ("host", "name"),
-    ]
-
-    def get(self, request, vimid="", tenantid="", hostname=""):
-        logger.debug("Hosts--get::> %s" % request.data)
-        try:
-            #prepare request resource to vim instance
-            req_resouce = "/os-hosts"
-            if hostname:
-                req_resouce += "/%s" % hostname
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            resp = sess.get(req_resouce, endpoint_filter=self.service)
-            content = resp.json()
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-            }
-            content.update(vim_dict)
-
-
-            if not hostname:
-                # convert the key naming in hosts
-                for host in content["hosts"]:
-                    VimDriverUtils.replace_key_by_mapping(host,
-                                                          self.hosts_keys_mapping)
-            else:
-                #restructure host data model
-                old_host = content["host"]
-                content["host"] = []
-                # convert the key naming in resources
-                for res in old_host:
-                    VimDriverUtils.replace_key_by_mapping(res['resource'],
-                                                          self.host_keys_mapping)
-                    content["host"].append(res['resource'])
-
-            return Response(data=content, status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
diff --git a/newton/newton/requests/views/image.py b/newton/newton/requests/views/image.py
deleted file mode 100644
index d4e8177b..00000000
--- a/newton/newton/requests/views/image.py
+++ /dev/null
@@ -1,236 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-import json
-from six.moves import urllib
-import threading
-import traceback
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from newton.pub.exceptions import VimDriverNewtonException
-
-from newton.requests.views.util import VimDriverUtils
-
-logger = logging.getLogger(__name__)
-
-running_threads = {}
-running_thread_lock = threading.Lock()
-
-class imageThread (threading.Thread):
-    service = {'service_type': 'image',
-               'interface': 'public'}
-    def __init__(self, vimid, tenantid, imageid, imagefd):
-        threading.Thread.__init__(self)
-        self.vimid = vimid
-        self.tenantid = tenantid
-        self.imageid = imageid
-        self.imagefd = imagefd
-
-    def run(self):
-        logger.debug("start imagethread %s, %s, %s" % (self.vimid, self.tenantid, self.imageid))
-        self.transfer_image(self.vimid, self.tenantid, self.imageid, self.imagefd)
-        logger.debug("stop imagethread %s, %s, %s" % (self.vimid, self.tenantid, self.imageid))
-        running_thread_lock.acquire()
-        running_threads.pop(self.imageid)
-        running_thread_lock.release()
-
-    def transfer_image(self, vimid, tenantid, imageid, imagefd):
-        logger.debug("Images--transfer_image::> %s" % (imageid))
-        try:
-            # prepare request resource to vim instance
-            req_resouce = "v2/images/%s/file" % imageid
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-
-            #open imageurl
-            resp = sess.put(req_resouce, endpoint_filter=self.service, data=imagefd.read(),
-                    headers={"Content-Type": "application/octet-stream",
-                             "Accept": ""})
-
-            logger.debug("response status code of transfer_image %s" % resp.status_code)
-            return None
-        except HttpError as e:
-            logger.error("transfer_image, HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return None
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            logger.error("Failed to transfer_image:%s" % str(e))
-            return None
-
-class Images(APIView):
-    service = {'service_type': 'image',
-               'interface': 'public'}
-    keys_mapping = [
-        ("project_id", "tenantId"),
-        ("disk_format", "imageType"),
-        ("container_format", "containerFormat")
-    ]
-
-    def get(self, request, vimid="", tenantid="", imageid=""):
-        logger.debug("Images--get::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            query = VimDriverUtils.get_query_part(request)
-            content, status_code = self.get_images(query, vimid, tenantid, imageid)
-            return Response(data=content, status=status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def get_images(self, query="", vimid="", tenantid="", imageid=""):
-        logger.debug("Images--get_images::> %s" % imageid)
-
-        # prepare request resource to vim instance
-        req_resouce = "v2/images"
-        if imageid:
-            req_resouce += "/%s" % imageid
-        elif query:
-            req_resouce += "?%s" % query
-
-        vim = VimDriverUtils.get_vim_info(vimid)
-        sess = VimDriverUtils.get_session(vim, tenantid)
-        resp = sess.get(req_resouce, endpoint_filter=self.service)
-        content = resp.json()
-        vim_dict = {
-            "vimName": vim["name"],
-            "vimId": vim["vimId"],
-            "tenantId": tenantid,
-        }
-        content.update(vim_dict)
-
-        if not imageid:
-            # convert the key naming in images
-            for image in content["images"]:
-                VimDriverUtils.replace_key_by_mapping(image,
-                                                      self.keys_mapping)
-        else:
-            # convert the key naming in the image specified by id
-            #image = content.pop("image", None)
-            VimDriverUtils.replace_key_by_mapping(content,
-                                                  self.keys_mapping)
-            #content.update(image)
-
-        return content, resp.status_code
-
-    def post(self, request, vimid="", tenantid="", imageid=""):
-        logger.debug("Images--post::> %s" % request.data)
-        try:
-            #check if created already: check name
-            query = "name=%s" % request.data["name"]
-            content, status_code = self.get_images(query, vimid, tenantid)
-            existed = False
-            if status_code == 200:
-                for image in content["images"]:
-                    if image["name"] == request.data["name"]:
-                        existed = True
-                        break
-                if existed == True:
-                    vim_dict = {
-                        "returnCode": 0,
-                    }
-                    image.update(vim_dict)
-                    return Response(data=image, status=status_code)
-
-            imageurl = request.data.pop("imagePath", None)
-            imagefd = None
-            if not imageurl:
-                return Response(data={'error': 'imagePath is not specified'}, status=500)
-
-            #valid image url
-            imagefd = urllib.request.urlopen(imageurl)
-            if not imagefd:
-                logger.debug("image is not available at %s" % imageurl)
-                return Response(data={'error': 'cannot access to specified imagePath'}, status=500)
-
-                # prepare request resource to vim instance
-            req_resouce = "v2/images"
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            image = request.data
-            VimDriverUtils.replace_key_by_mapping(image,
-                                                  self.keys_mapping, True)
-            #req_body = json.JSONEncoder().encode({"image": image})
-            req_body = json.JSONEncoder().encode(image)
-            resp = sess.post(req_resouce, data=req_body,
-                             endpoint_filter=self.service)
-            #resp_body = resp.json()["image"]
-            resp_body = resp.json()
-            VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping)
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-                "returnCode": 1,
-            }
-            resp_body.update(vim_dict)
-
-            #launch a thread to download image and upload to VIM
-            if resp.status_code == 201:
-                imageid = resp_body["id"]
-                logger.debug("launch thread to upload image: %s" % imageid)
-                tmp_thread = imageThread(vimid, tenantid,imageid,imagefd)
-                running_thread_lock.acquire()
-                running_threads[imageid] = tmp_thread
-                running_thread_lock.release()
-                tmp_thread.start()
-            else:
-                logger.debug("resp.status_code: %s" % resp.status_code)
-
-            return Response(data=resp_body, status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except urllib.error.URLError as e:
-            return Response(data={'error': 'image is not accessible:%s' % str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def delete(self, request, vimid="", tenantid="", imageid=""):
-        logger.debug("Images--delete::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            req_resouce = "v2/images"
-            if imageid:
-                req_resouce += "/%s" % imageid
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            resp = sess.delete(req_resouce, endpoint_filter=self.service)
-            return Response(status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
diff --git a/newton/newton/requests/views/limits.py b/newton/newton/requests/views/limits.py
deleted file mode 100644
index 7f6156c8..00000000
--- a/newton/newton/requests/views/limits.py
+++ /dev/null
@@ -1,83 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-import json
-import traceback
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from newton.pub.exceptions import VimDriverNewtonException
-
-from newton.requests.views.util import VimDriverUtils
-
-logger = logging.getLogger(__name__)
-
-
-class Limits(APIView):
-    service = {'service_type': 'compute',
-               'interface': 'public'}
-
-    service_network = {'service_type': 'network',
-               'interface': 'public'}
-
-    service_volume = {'service_type': 'volumev2',
-               'interface': 'public'}
-
-    def get(self, request, vimid="", tenantid=""):
-        logger.debug("Limits--get::> %s" % request.data)
-        try:
-            #get limits first
-            # prepare request resource to vim instance
-            req_resouce = "/limits"
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            resp = sess.get(req_resouce, endpoint_filter=self.service)
-            content = resp.json()
-            content_all =content['limits']['absolute']
-
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-            }
-            content_all.update(vim_dict)
-
-            #now get quota
-            # prepare request resource to vim instance
-            req_resouce = "/v2.0/quotas/%s" % tenantid
-            resp = sess.get(req_resouce, endpoint_filter=self.service_network)
-            content = resp.json()
-            content_all.update(content['quota'])
-
-            #now get volume limits
-            # prepare request resource to vim instance
-            req_resouce = "/limits"
-            resp = sess.get(req_resouce, endpoint_filter=self.service_volume)
-            content = resp.json()
-            content_all.update(content['limits']['absolute'])
-
-            return Response(data=content_all, status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
diff --git a/newton/newton/requests/views/network.py b/newton/newton/requests/views/network.py
deleted file mode 100644
index b4cdbdf9..00000000
--- a/newton/newton/requests/views/network.py
+++ /dev/null
@@ -1,172 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-import json
-import traceback
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from newton.pub.exceptions import VimDriverNewtonException
-
-from newton.requests.views.util import VimDriverUtils
-
-logger = logging.getLogger(__name__)
-
-
-class Networks(APIView):
-    service = {'service_type': 'network',
-               'interface': 'public'}
-    keys_mapping = [
-        ("provider:segmentation_id", "segmentationId"),
-        ("provider:physical_network", "physicalNetwork"),
-        ("router:external", "routerExternal"),
-        ("provider:network_type", "networkType"),
-        ("vlan_transparent", "vlanTransparent"),
-        ("project_id", "tenantId"),
-    ]
-
-    def get(self, request, vimid="", tenantid="", networkid=""):
-        logger.debug("Networks--get::> %s" % request.data)
-        try:
-            query = VimDriverUtils.get_query_part(request)
-            content, status_code = self.get_networks(query, vimid, tenantid, networkid)
-            return Response(data=content, status=status_code)
-
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def get_networks(self, query, vimid="", tenantid="", networkid=""):
-        logger.debug("Networks--get_networks::> %s" % networkid)
-
-        # prepare request resource to vim instance
-        req_resouce = "v2.0/networks"
-        if networkid:
-            req_resouce += "/%s" % networkid
-
-        if query:
-            req_resouce += "?%s" % query
-
-        vim = VimDriverUtils.get_vim_info(vimid)
-        sess = VimDriverUtils.get_session(vim, tenantid)
-        resp = sess.get(req_resouce, endpoint_filter=self.service)
-        content = resp.json()
-        vim_dict = {
-            "vimName": vim["name"],
-            "vimId": vim["vimId"],
-            "tenantId": tenantid,
-        }
-        content.update(vim_dict)
-
-        if not networkid:
-            # convert the key naming in networks
-            for network in content["networks"]:
-                VimDriverUtils.replace_key_by_mapping(network,
-                                                      self.keys_mapping)
-        else:
-            # convert the key naming in the network specified by id
-            network = content.pop("network", None)
-            VimDriverUtils.replace_key_by_mapping(network,
-                                                  self.keys_mapping)
-            content.update(network)
-
-        return content, resp.status_code
-
-    def post(self, request, vimid="", tenantid="", networkid=""):
-        logger.debug("Networks--post::> %s" % request.data)
-        try:
-            #check if created already: check name
-            query = "name=%s" % request.data["name"]
-            content, status_code = self.get_networks(query, vimid, tenantid)
-            existed = False
-            if status_code == 200:
-                for network in content["networks"]:
-                    if network["name"] == request.data["name"]:
-                        existed = True
-                        break
-                if existed == True:
-                    vim_dict = {
-                        "returnCode": 0,
-                    }
-                    network.update(vim_dict)
-                    return Response(data=network, status=status_code)
-
-            # prepare request resource to vim instance
-            req_resouce = "v2.0/networks"
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            network = request.data
-            VimDriverUtils.replace_key_by_mapping(network,
-                                                  self.keys_mapping, True)
-            req_body = json.JSONEncoder().encode({"network": network})
-            resp = sess.post(req_resouce, data=req_body,
-                             endpoint_filter=self.service)
-            resp_body = resp.json()["network"]
-            VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping)
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-                "returnCode": 1,
-            }
-            resp_body.update(vim_dict)
-            return Response(data=resp_body, status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def delete(self, request, vimid="", tenantid="", networkid=""):
-        logger.debug("Networks--delete::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            req_resouce = "v2.0/networks"
-            if networkid:
-                req_resouce += "/%s" % networkid
-            query = VimDriverUtils.get_query_part(request)
-            if query:
-                req_resouce += "?%s" % query
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            resp = sess.delete(req_resouce, endpoint_filter=self.service)
-            return Response(status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-class Subnets(APIView):
-    pass
diff --git a/newton/newton/requests/views/server.py b/newton/newton/requests/views/server.py
deleted file mode 100644
index 65bca06d..00000000
--- a/newton/newton/requests/views/server.py
+++ /dev/null
@@ -1,426 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-import json
-import threading
-import traceback
-
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from newton.pub.exceptions import VimDriverNewtonException
-from newton.requests.views.util import VimDriverUtils
-
-logger = logging.getLogger(__name__)
-
-
-running_threads = {}
-running_thread_lock = threading.Lock()
-
-
-#assume volume is attached on server creation
-class ServerVolumeAttachThread (threading.Thread):
-    service = {'service_type': 'compute',
-               'interface': 'public'}
-    def __init__(self, vimid, tenantid, serverid, is_attach, *volumeids):
-        threading.Thread.__init__(self)
-        self.vimid = vimid
-        self.tenantid = tenantid
-        self.serverid = serverid
-        self.volumeids = volumeids
-        self.is_attach = is_attach
-
-    def run(self):
-        logger.debug("start server thread %s, %s, %s" % (self.vimid, self.tenantid, self.serverid))
-        if (self.is_attach):
-            self.attach_volume(self.vimid, self.tenantid, self.serverid, *self.volumeids)
-        else:
-            self.detach_volume(self.vimid, self.tenantid, self.serverid, *self.volumeids)
-        logger.debug("stop server thread %s, %s, %s" % (self.vimid, self.tenantid, self.serverid))
-        running_thread_lock.acquire()
-        running_threads.pop(self.serverid)
-        running_thread_lock.release()
-
-    def attach_volume(self, vimid, tenantid, serverid, *volumeids):
-        logger.debug("Server--attach_volume::> %s, %s" % (serverid, volumeids))
-        try:
-            # prepare request resource to vim instance
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-
-            #check if server is ready to attach
-            logger.debug("Servers--attach_volume, wait for server to be ACTIVE::>%s" % serverid)
-            req_resouce = "servers/%s" % serverid
-            while True:
-                resp = sess.get(req_resouce, endpoint_filter=self.service)
-                content = resp.json()
-                if content and content["server"] and content["server"]["status"] == "ACTIVE":
-                    break;
-
-            for volumeid in volumeids:
-                req_resouce = "servers/%s/os-volume_attachments" % serverid
-                req_data = {"volumeAttachment": {
-                    "volumeId": volumeid
-                }}
-                logger.debug("Servers--attach_volume::>%s, %s" % (req_resouce, req_data))
-                req_body = json.JSONEncoder().encode(req_data)
-                resp = sess.post(req_resouce, data=req_body,
-                                 endpoint_filter=self.service,
-                                 headers={"Content-Type": "application/json",
-                                          "Accept": "application/json"})
-                logger.debug("Servers--attach_volume resp::>%s" % resp.json())
-
-            return None
-        except HttpError as e:
-            logger.error("attach_volume, HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return None
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            logger.debug("Failed to attach_volume:%s" % str(e))
-            return None
-
-
-    def detach_volume(self, vimid, tenantid, serverid, *volumeids):
-        logger.debug("Server--detach_volume::> %s, %s" % (serverid, volumeids))
-        try:
-            # prepare request resource to vim instance
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-
-            #wait server to be ready to detach volume
-
-            # assume attachment id is the same as volume id
-            for volumeid in volumeids:
-                req_resouce = "servers/%s/os-volume_attachments/%s" % (serverid, volumeid)
-
-                logger.debug("Servers--dettachVolume::>%s" % (req_resouce))
-                resp = sess.delete(req_resouce,
-                                   endpoint_filter=self.service,
-                                   headers={"Content-Type": "application/json",
-                                            "Accept": "application/json"})
-
-                logger.debug("Servers--dettachVolume resp::>%s" % resp.json())
-
-            return None
-        except HttpError as e:
-            logger.error("detach_volume, HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return None
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            logger.debug("Failed to detach_volume:%s" % str(e))
-            return None
-
-
-class Servers(APIView):
-    service = {'service_type': 'compute',
-               'interface': 'public'}
-    keys_mapping = [
-        ("tenant_id", "tenantId"),
-        ("flavorRef", "flavorId"),
-        ("user_data", "userdata"),
-        ("security_groups", "securityGroups"),
-        ("availability_zone ", "availabilityZone"),
-        ("os-extended-volumes:volumes_attached", "volumeArray"),
-    ]
-
-    def _attachVolume(self, vimid, tenantid, serverId, *volumeIds):
-        #has to be async mode to wait server is ready to attach volume
-        logger.debug("launch thread to attach volume: %s" % serverId)
-        tmp_thread = ServerVolumeAttachThread(vimid, tenantid, serverId, True, *volumeIds)
-        running_thread_lock.acquire()
-        running_threads[serverId] = tmp_thread
-        running_thread_lock.release()
-        tmp_thread.start()
-
-    def _dettach_volume(self, vimid, tenantid, serverId, *volumeIds):
-        # assume attachment id is the same as volume id
-        vim = VimDriverUtils.get_vim_info(vimid)
-        sess = VimDriverUtils.get_session(vim, tenantid)
-
-        for volumeid in volumeIds:
-            req_resouce = "servers/%s/os-volume_attachments/%s" % (serverId, volumeid)
-            logger.debug("Servers--dettachVolume::>%s" % (req_resouce))
-            resp = sess.delete(req_resouce,
-                               endpoint_filter=self.service,
-                               headers={"Content-Type": "application/json",
-                                        "Accept": "application/json"})
-            logger.debug("Servers--dettachVolume resp status::>%s" % resp.status_code)
-
-    def _convert_metadata(self, metadata, metadata_output, reverse=True):
-        if not reverse:
-            # from extraSpecs to extra_specs
-            for spec in metadata:
-                metadata_output[spec['keyName']] = spec['value']
-        else:
-            for k, v in metadata_output.items():
-                spec = {}
-                spec['keyName'] = k
-                spec['value'] = v
-                metadata.append(spec)
-
-    def _convert_resp(self, server):
-        #convert volumeArray
-        volumeArray = server.pop("volumeArray", None)
-        tmpVolumeArray = []
-        if volumeArray and len(volumeArray) > 0:
-            for vol in volumeArray:
-                tmpVolumeArray.append({"volumeId": vol["id"]})
-        server["volumeArray"] = tmpVolumeArray if len(tmpVolumeArray) > 0 else None
-
-        #convert flavor
-        flavor = server.pop("flavor", None)
-        server["flavorId"] = flavor["id"] if flavor else None
-
-        #convert nicArray
-
-        #convert boot
-        imageObj = server.pop("image", None)
-        imageId = imageObj.pop("id", None) if imageObj else None
-        if imageId:
-            server["boot"] = {"type":2, "imageId": imageId}
-        else:
-            server["boot"] = {"type":1, "volumeId":tmpVolumeArray.pop(0)["volumeId"] if len(tmpVolumeArray) > 0 else None}
-
-        #convert OS-EXT-AZ:availability_zone
-        server["availabilityZone"] = server.pop("OS-EXT-AZ:availability_zone", None)
-
-    def get(self, request, vimid="", tenantid="", serverid=""):
-        logger.debug("Servers--get::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            query = VimDriverUtils.get_query_part(request)
-            content, status_code = self._get_servers(query, vimid, tenantid, serverid)
-            return Response(data=content, status=status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def _get_ports(self, vimid="", tenantid="", serverid=None):
-        # query attached ports
-        vim = VimDriverUtils.get_vim_info(vimid)
-        sess = VimDriverUtils.get_session(vim, tenantid)
-        req_resouce = "servers/%s/os-interface" % serverid
-        resp = sess.get(req_resouce, endpoint_filter=self.service)
-        ports = resp.json()
-        if ports and ports["interfaceAttachments"] and len(ports["interfaceAttachments"]) > 0:
-            return [{"portId":port["port_id"]} for port in ports["interfaceAttachments"]]
-        return None
-
-    def _get_servers(self, query="", vimid="", tenantid="", serverid=None):
-        logger.debug("Servers--get_servers::> %s,%s" % (tenantid, serverid))
-
-        # prepare request resource to vim instance
-        req_resouce = "servers"
-        if serverid:
-            req_resouce += "/%s" % serverid
-        else:
-            req_resouce += "/detail"
-            if query:
-                req_resouce += "?%s" % query
-
-        vim = VimDriverUtils.get_vim_info(vimid)
-        sess = VimDriverUtils.get_session(vim, tenantid)
-        resp = sess.get(req_resouce, endpoint_filter=self.service)
-        content = resp.json()
-        vim_dict = {
-            "vimName": vim["name"],
-            "vimId": vim["vimId"],
-            "tenantId": tenantid,
-        }
-        content.update(vim_dict)
-
-        if not serverid:
-            # convert the key naming in servers
-            for server in content["servers"]:
-                metadata = server.pop("metadata", None)
-                if metadata:
-                    meta_data = []
-                    self._convert_metadata(metadata, meta_data, False)
-                    server["metadata"] = meta_data
-                VimDriverUtils.replace_key_by_mapping(server,
-                                                      self.keys_mapping)
-                self._convert_resp(server)
-                server["nicArray"] = self._get_ports(vimid, tenantid, server["id"])
-
-        else:
-            # convert the key naming in the server specified by id
-            server = content.pop("server", None)
-            metadata = server.pop("metadata", None)
-            if metadata:
-                meta_data = []
-                self._convert_metadata(metadata, meta_data)
-                server["metadata"] = meta_data
-            VimDriverUtils.replace_key_by_mapping(server,
-                                                  self.keys_mapping)
-            self._convert_resp(server)
-            server["nicArray"] = self._get_ports(vimid, tenantid, serverid)
-            content.update(server)
-
-        return content, resp.status_code
-
-    def post(self, request, vimid="", tenantid="", serverid=""):
-        logger.debug("Servers--post::> %s" % request.data)
-        try:
-            # check if created already: check name
-            servername = request.data["name"]
-            query = "name=%s" % servername
-            content, status_code = self._get_servers(query, vimid, tenantid)
-            existed = False
-            if status_code == status.HTTP_200_OK:
-                for server in content["servers"]:
-                    if server["name"] == request.data["name"]:
-                        existed = True
-                        break
-                if existed and server:
-                    vim_dict = {
-                        "returnCode": 0,
-                    }
-                    server.update(vim_dict)
-                    return Response(data=server, status=status_code)
-
-            # prepare request resource to vim instance
-            req_resouce = "servers"
-            server = request.data
-
-            # convert parameters
-            boot = server.pop("boot", None)
-            if not boot:
-                return Response(data={'error': "missing boot paramters"},
-                                status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-            if boot["type"] == 1:
-                # boot from volume
-                server["block_device_mapping_v2"] = [{"uuid": boot["volumeId"],
-                                                      "source_type": "volume",
-                                                      "destination_type": "volume",
-                                                      "delete_on_termination": "false",
-                                                      "boot_index": "0"}]
-            else:
-                # boot from image
-                server["imageRef"] = boot["imageId"]
-
-            nicarray = server.pop("nicArray", None)
-            if not nicarray:
-                return Response(data={'error': "missing nicArray paramters"},
-                                status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-            networks = []
-            for nic in nicarray:
-                networks.append({"port": nic["portId"]})
-            if len(networks) > 0:
-                server["networks"] = networks
-
-            meta_data = server.pop("metadata", None)
-            if meta_data:
-                metadata = {}
-                self._convert_metadata(metadata, meta_data, False)
-                server["metadata"] = metadata
-
-            contextarray = server.pop("contextArray", None)
-            volumearray = server.pop("volumeArray", None)
-            if contextarray:
-                # now set "contextArray" array
-                personalities = []
-                for context in contextarray:
-                    personalities.append({"path": context["fileName"], "contents": context["fileData"]})
-                if len(personalities) > 0:
-                    server["personality"] = personalities
-
-            VimDriverUtils.replace_key_by_mapping(server,
-                                                  self.keys_mapping, True)
-            req_body = json.JSONEncoder().encode({"server": server})
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            resp = sess.post(req_resouce, data=req_body,
-                             endpoint_filter=self.service,
-                             headers={"Content-Type": "application/json",
-                                      "Accept": "application/json"})
-
-            resp_body = resp.json().pop("server", None)
-
-            logger.debug("Servers--post status::>%s, %s" % (resp_body["id"], resp.status_code))
-            if resp.status_code in [status.HTTP_200_OK, status.HTTP_201_CREATED, status.HTTP_202_ACCEPTED]:
-                if volumearray and len(volumearray) > 0:
-                    # server is created, now attach volumes
-                    volumeIds = [extraVolume["volumeId"] for extraVolume in volumearray]
-                    self._attachVolume(vimid, tenantid, resp_body["id"], *volumeIds)
-
-            metadata = resp_body.pop("metadata", None)
-            if metadata:
-                meta_data = []
-                self._convert_metadata(metadata, meta_data)
-                resp_body["metadata"] = meta_data
-
-            VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping)
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-                "returnCode": 1,
-            }
-            resp_body.update(vim_dict)
-            resp_body["boot"] = boot
-            resp_body["volumeArray"] = volumearray
-            resp_body["nicArray"] = nicarray
-            resp_body["contextArray"] = contextarray
-            resp_body["name"] = servername
-            return Response(data=resp_body, status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def delete(self, request, vimid="", tenantid="", serverid=""):
-        logger.debug("Servers--delete::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-
-            #check and dettach them if volumes attached to server
-            server, status_code = self._get_servers("", vimid, tenantid, serverid)
-            volumearray = server.pop("volumeArray", None)
-            if volumearray and len(volumearray) > 0:
-                volumeIds = [extraVolume["volumeId"] for extraVolume in volumearray]
-                self._dettach_volume(vimid, tenantid, serverid, *volumeIds)
-
-            #delete server now
-            req_resouce = "servers"
-            if serverid:
-                req_resouce += "/%s" % serverid
-
-            resp = sess.delete(req_resouce, endpoint_filter=self.service)
-            return Response(status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
diff --git a/newton/newton/requests/views/subnet.py b/newton/newton/requests/views/subnet.py
deleted file mode 100644
index 4200e549..00000000
--- a/newton/newton/requests/views/subnet.py
+++ /dev/null
@@ -1,170 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-import json
-import traceback
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from newton.pub.exceptions import VimDriverNewtonException
-
-from newton.requests.views.util import VimDriverUtils
-
-logger = logging.getLogger(__name__)
-
-
-class Subnets(APIView):
-    service = {'service_type': 'network',
-               'interface': 'public'}
-    keys_mapping = [
-        ("project_id", "tenantId"),
-        ("network_id", "networkId"),
-        ("ip_version", "ipVersion"),
-        ("enable_dhcp", "enableDhcp"),
-        ("gateway_ip", "gatewayIp"),
-        ("dns_nameservers", "dnsNameservers"),
-        ("host_routes", "hostRoutes"),
-        ("allocation_pools", "allocationPools"),
-    ]
-
-    def get(self, request, vimid="", tenantid="", subnetid=""):
-        logger.debug("Subnets--get::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            query = VimDriverUtils.get_query_part(request)
-            content, status_code = self.get_subnets(query, vimid, tenantid, subnetid)
-            return Response(data=content, status=status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def get_subnets(self, query="", vimid="", tenantid="", subnetid=""):
-        logger.debug("Subnets--get_subnets::> %s" % subnetid)
-
-        # prepare request resource to vim instance
-        req_resouce = "v2.0/subnets"
-        if subnetid:
-            req_resouce += "/%s" % subnetid
-
-        if query:
-            req_resouce += "?%s" % query
-
-        vim = VimDriverUtils.get_vim_info(vimid)
-        sess = VimDriverUtils.get_session(vim, tenantid)
-        resp = sess.get(req_resouce, endpoint_filter=self.service)
-        content = resp.json()
-        vim_dict = {
-            "vimName": vim["name"],
-            "vimId": vim["vimId"],
-            "tenantId": tenantid,
-        }
-        content.update(vim_dict)
-
-        if not subnetid:
-            # convert the key naming in subnets
-            for subnet in content["subnets"]:
-                VimDriverUtils.replace_key_by_mapping(subnet,
-                                                      self.keys_mapping)
-        else:
-            # convert the key naming in the subnet specified by id
-            subnet = content.pop("subnet", None)
-            VimDriverUtils.replace_key_by_mapping(subnet,
-                                                  self.keys_mapping)
-            content.update(subnet)
-
-        return content, resp.status_code
-
-    def post(self, request, vimid="", tenantid="", subnetid=""):
-        logger.debug("Subnets--post::> %s" % request.data)
-        try:
-            #check if created already: check name
-            query = "name=%s" % request.data["name"]
-            content, status_code = self.get_subnets(query, vimid, tenantid)
-            existed = False
-            if status_code == 200:
-                for subnet in content["subnets"]:
-                    if subnet["name"] == request.data["name"]:
-                        existed = True
-                        break
-                if existed == True:
-                    vim_dict = {
-                        "returnCode": 0,
-                    }
-                    subnet.update(vim_dict)
-                    return Response(data=subnet, status=status_code)
-
-            # prepare request resource to vim instance
-            req_resouce = "v2.0/subnets"
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            subnet = request.data
-            VimDriverUtils.replace_key_by_mapping(subnet,
-                                                  self.keys_mapping, True)
-            req_body = json.JSONEncoder().encode({"subnet": subnet})
-            resp = sess.post(req_resouce, data=req_body,
-                             endpoint_filter=self.service)
-            resp_body = resp.json()["subnet"]
-            VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping)
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-                "returnCode": 1,
-            }
-            resp_body.update(vim_dict)
-            return Response(data=resp_body, status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def delete(self, request, vimid="", tenantid="", subnetid=""):
-        logger.debug("Subnets--delete::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            req_resouce = "v2.0/subnets"
-            if subnetid:
-                req_resouce += "/%s" % subnetid
-            query = VimDriverUtils.get_query_part(request)
-            if query:
-                req_resouce += "?%s" % query
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            resp = sess.delete(req_resouce, endpoint_filter=self.service)
-            return Response(status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
diff --git a/newton/newton/requests/views/tenants.py b/newton/newton/requests/views/tenants.py
deleted file mode 100644
index 0bdc599e..00000000
--- a/newton/newton/requests/views/tenants.py
+++ /dev/null
@@ -1,85 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-import traceback
-
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from newton.pub.exceptions import VimDriverNewtonException
-from newton.requests.views.util import VimDriverUtils
-
-logger = logging.getLogger(__name__)
-
-
-class Tenants(APIView):
-    service = {
-        'service_type': 'identity',
-        'interface': 'public'
-    }
-
-    keys_mapping = [
-        ("projects", "tenants"),
-    ]
-
-    def get(self, request, vimid=""):
-        logger.debug("Tenants--get::> %s" % request.data)
-        try:
-            #prepare request resource to vim instance
-            query = VimDriverUtils.get_query_part(request)
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            req_resouce = "/projects"
-            if '/v2' in vim["url"]:
-                req_resouce = "/v2.0/tenants"
-
-            sess = VimDriverUtils.get_session(vim)
-            resp = sess.get(req_resouce, endpoint_filter=self.service)
-            content = resp.json()
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-            }
-            content.update(vim_dict)
-
-            VimDriverUtils.replace_key_by_mapping(
-                content, self.keys_mapping)
-
-            if query:
-               _, tenantname = query.split('=')
-               if tenantname:
-                   tmp = content["tenants"]
-                   content["tenants"] = []
-                   # convert the key naming in hosts
-                   for tenant in tmp:
-                       if tenantname == tenant['name']:
-                           content["tenants"].append(tenant)
-
-            return Response(data=content, status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(
-                data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (
-                e.http_status, e.response.json()))
-            return Response(data=e.response.json(),
-                            status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(
-                data={'error': str(e)},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR)
diff --git a/newton/newton/requests/views/util.py b/newton/newton/requests/views/util.py
deleted file mode 100644
index e547c69a..00000000
--- a/newton/newton/requests/views/util.py
+++ /dev/null
@@ -1,149 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-
-from django.conf import settings
-from django.core.cache import cache
-from keystoneauth1.identity import v2 as keystone_v2
-from keystoneauth1.identity import v3 as keystone_v3
-from keystoneauth1 import session
-
-from newton.pub.msapi import extsys
-
-logger = logging.getLogger(__name__)
-
-
-class VimDriverUtils(object):
-    @staticmethod
-    def get_vim_info(vimid):
-        """
-        Retrieve VIM information.
-
-        :param vimid: VIM Identifier
-        :return: VIM information
-        """
-        # TODO: get vim info from local cache firstly later from ESR
-        return extsys.get_vim_by_id(vimid)
-
-    @staticmethod
-    def delete_vim_info(vimid):
-        return extsys.delete_vim_by_id(vimid)
-
-    @staticmethod
-    def get_query_part(request):
-        query = ""
-        full_path = request.get_full_path()
-        if '?' in full_path:
-            _, query = full_path.split('?')
-        return query
-
-    @staticmethod
-    def get_session(
-            vim, tenant_id=None, tenant_name=None, auth_state=None):
-        """
-        get session object and optionally preload auth_state
-        """
-        auth = None
-
-        params = {
-            "auth_url": vim["url"],
-            "username": vim["userName"],
-            "password": vim["password"],
-        }
-
-        # tenantid takes precedence over tenantname
-        if tenant_id:
-            params["tenant_id"] = tenant_id
-        else:
-            # input tenant name takes precedence over the default one
-            # from AAI data store
-            params["tenant_name"] = (tenant_name if tenant_name
-                                     else vim['tenant'])
-
-        if '/v2' in params["auth_url"]:
-            auth = keystone_v2.Password(**params)
-        else:
-            params["user_domain_name"] = vim["domain"]
-            params["project_domain_name"] = vim["domain"]
-
-            if 'tenant_id' in params:
-                params["project_id"] = params.pop("tenant_id")
-            if 'tenant_name' in params:
-                params["project_name"] = params.pop("tenant_name")
-            if '/v3' not in params["auth_url"]:
-                params["auth_url"] = params["auth_url"] + "/v3",
-            auth = keystone_v3.Password(**params)
-
-        #preload auth_state which was acquired in last requests
-        if auth_state:
-           auth.set_auth_state(auth_state)
-
-        return session.Session(auth=auth)
-
-    @staticmethod
-    def get_auth_state(session_obj):
-        """
-        Retrieve the authorization state
-        :param session: OpenStack Session object
-        :return: return a string dump of json object with token and
-        resp_data of authentication request
-        """
-        auth = session_obj._auth_required(None, 'fetch a token')
-        if auth:
-            #trigger the authenticate request
-            session_obj.get_auth_headers(auth)
-
-            # norm_expires = utils.normalize_time(auth.expires)
-            return auth.get_auth_state()
-
-    @staticmethod
-    def get_token_cache(token):
-        """
-        get auth_state and metadata fromm cache
-        :param token:
-        :return:
-        """
-        return cache.get(token), cache.get("meta_%s" % token)
-
-    @staticmethod
-    def update_token_cache(token, auth_state, metadata):
-        """
-        Stores into the cache the auth_state and metadata_catalog
-        information.
-
-        :param token: Base token to be used as an identifier
-        :param auth_state: Authorization information
-        :param metadata: Metadata Catalog information
-        """
-        if metadata and not cache.get(token):
-            cache.set(
-                token, auth_state, settings.CACHE_EXPIRATION_TIME)
-            cache.set(
-                "meta_%s" % token, metadata,
-                settings.CACHE_EXPIRATION_TIME)
-
-    @staticmethod
-    def _replace_a_key(dict_obj, key_pair, reverse):
-        old_key = key_pair[1] if reverse else key_pair[0]
-        new_key = key_pair[0] if reverse else key_pair[1]
-
-        old_value = dict_obj.pop(old_key, None)
-        if old_value:
-            dict_obj[new_key] = old_value
-
-    @staticmethod
-    def replace_key_by_mapping(dict_obj, mapping, reverse=False):
-        for k in mapping:
-            VimDriverUtils._replace_a_key(dict_obj, k, reverse)
diff --git a/newton/newton/requests/views/volume.py b/newton/newton/requests/views/volume.py
deleted file mode 100644
index 26c9a14b..00000000
--- a/newton/newton/requests/views/volume.py
+++ /dev/null
@@ -1,169 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-import json
-import traceback
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from newton.pub.exceptions import VimDriverNewtonException
-
-from newton.requests.views.util import VimDriverUtils
-
-logger = logging.getLogger(__name__)
-
-
-class Volumes(APIView):
-    service = {'service_type': 'volumev2',
-               'interface': 'public'}
-    keys_mapping = [
-        ("project_id", "tenantId"),
-        ("created_at", "createTime"),
-        ("size", "volumeSize"),
-        ("volume_type", "volumeType"),
-        ("imageRef", "imageId"),
-        ("availability_zone", "availabilityZone"),
-        ("server_id", "serverId"),
-        ("attachment_id", "attachmentId"),
-    ]
-
-    def get(self, request, vimid="", tenantid="", volumeid=""):
-        logger.debug("Volumes--get::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            query = VimDriverUtils.get_query_part(request)
-            content, status_code = self.get_volumes(query, vimid, tenantid, volumeid)
-            return Response(data=content, status=status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def get_volumes(self, query="", vimid="", tenantid="", volumeid=None):
-        logger.debug("Volumes--get_volumes::> %s,%s" % (tenantid, volumeid))
-
-        # prepare request resource to vim instance
-        req_resouce = "volumes"
-        if volumeid:
-            req_resouce += "/%s" % volumeid
-        else:
-            req_resouce += "/detail"
-            if query:
-                req_resouce += "?%s" % query
-
-        vim = VimDriverUtils.get_vim_info(vimid)
-        sess = VimDriverUtils.get_session(vim, tenantid)
-        resp = sess.get(req_resouce, endpoint_filter=self.service)
-        content = resp.json()
-        vim_dict = {
-            "vimName": vim["name"],
-            "vimId": vim["vimId"],
-            "tenantId": tenantid,
-        }
-        content.update(vim_dict)
-
-        if not volumeid:
-            # convert the key naming in volumes
-            for volume in content["volumes"]:
-                VimDriverUtils.replace_key_by_mapping(volume,
-                                                      self.keys_mapping)
-        else:
-            # convert the key naming in the volume specified by id
-            volume = content.pop("volume", None)
-            VimDriverUtils.replace_key_by_mapping(volume,
-                                                  self.keys_mapping)
-            content.update(volume)
-
-        return content, resp.status_code
-
-    def post(self, request, vimid="", tenantid="", volumeid=""):
-        logger.debug("Volumes--post::> %s" % request.data)
-        try:
-            #check if created already: check name
-            query = "name=%s" % request.data["name"]
-            content, status_code = self.get_volumes(query, vimid, tenantid)
-            existed = False
-            if status_code == 200:
-                for volume in content["volumes"]:
-                    if volume["name"] == request.data["name"]:
-                        existed = True
-                        break
-                if existed == True:
-                    vim_dict = {
-                        "returnCode": 0,
-                    }
-                    volume.update(vim_dict)
-                    return Response(data=volume, status=status_code)
-
-            # prepare request resource to vim instance
-            req_resouce = "volumes"
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            volume = request.data
-            VimDriverUtils.replace_key_by_mapping(volume,
-                                                  self.keys_mapping, True)
-            req_body = json.JSONEncoder().encode({"volume": volume})
-            resp = sess.post(req_resouce, data=req_body,
-                             endpoint_filter=self.service, headers={"Content-Type": "application/json",
-                             "Accept": "application/json" })
-            resp_body = resp.json()["volume"]
-            VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping)
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-                "returnCode": 1,
-            }
-            resp_body.update(vim_dict)
-            return Response(data=resp_body, status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def delete(self, request, vimid="", tenantid="", volumeid=""):
-        logger.debug("Volumes--delete::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            req_resouce = "volumes"
-            if volumeid:
-                req_resouce += "/%s" % volumeid
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            resp = sess.delete(req_resouce, endpoint_filter=self.service)
-            return Response(status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
diff --git a/newton/newton/requests/views/vport.py b/newton/newton/requests/views/vport.py
deleted file mode 100644
index 827ee7f3..00000000
--- a/newton/newton/requests/views/vport.py
+++ /dev/null
@@ -1,203 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# 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.
-
-import logging
-import json
-import traceback
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from newton.pub.exceptions import VimDriverNewtonException
-
-from newton.requests.views.util import VimDriverUtils
-
-logger = logging.getLogger(__name__)
-
-
-class Vports(APIView):
-    service = {'service_type': 'network',
-               'interface': 'public'}
-    keys_mapping = [
-        ("project_id", "tenantId"),
-        ("network_id", "networkId"),
-        ("binding:vnic_type", "vnicType"),
-        ("security_groups", "securityGroups"),
-        ("mac_address", "macAddress"),
-        ("subnet_id", "subnetId"),
-        ("ip_address", "ip"),
-    ]
-
-    def get(self, request, vimid="", tenantid="", portid=""):
-        logger.debug("Ports--get::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            query = VimDriverUtils.get_query_part(request)
-            content, status_code = self.get_ports(query, vimid, tenantid, portid)
-
-            return Response(data=content, status=status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def get_ports(self, query="", vimid="", tenantid="", portid=""):
-        logger.debug("Ports--get_ports::> %s" % portid)
-        vim = VimDriverUtils.get_vim_info(vimid)
-        sess = VimDriverUtils.get_session(vim, tenantid)
-
-        if sess:
-            # prepare request resource to vim instance
-            req_resouce = "v2.0/ports"
-            if portid:
-                req_resouce += "/%s" % portid
-
-            if query:
-                req_resouce += "?%s" % query
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            resp = sess.get(req_resouce, endpoint_filter=self.service)
-            content = resp.json()
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-            }
-            content.update(vim_dict)
-
-            if not portid:
-                # convert the key naming in ports
-                for port in content["ports"]:
-                    # use only 1st entry of fixed_ips
-                    tmpips = port.pop("fixed_ips", None) if port else None
-                    port.update(tmpips[0]) if tmpips and len(tmpips) > 0 else None
-                    VimDriverUtils.replace_key_by_mapping(port,
-                                                          self.keys_mapping)
-            else:
-                # convert the key naming in the port specified by id
-                port = content.pop("port", None)
-                #use only 1st entry of fixed_ips
-                tmpips = port.pop("fixed_ips", None) if port else None
-                port.update(tmpips[0]) if tmpips and len(tmpips) > 0 else None
-
-                VimDriverUtils.replace_key_by_mapping(port,
-                                                      self.keys_mapping)
-                content.update(port)
-            return content, resp.status_code
-        return {}, 500
-
-    def post(self, request, vimid="", tenantid="", portid=""):
-        logger.debug("Ports--post::> %s" % request.data)
-        try:
-            #check if already created: name
-            query = "name=%s" % request.data["name"]
-            content, status_code = self.get_ports(query, vimid, tenantid, portid)
-            existed = False
-            if status_code == 200:
-                for port in content["ports"]:
-                    if port["name"] == request.data["name"]:
-                        existed = True
-                        break
-                if existed == True:
-                    vim_dict = {
-                         "returnCode": 0,
-                    }
-                    port.update(vim_dict)
-                    return Response(data=port, status=status_code)
-
-            #otherwise create a new one
-            return self.create_port(request, vimid, tenantid)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-    def create_port(self, request, vimid, tenantid):
-        logger.debug("Ports--create::> %s" % request.data)
-        vim = VimDriverUtils.get_vim_info(vimid)
-        sess = VimDriverUtils.get_session(vim, tenantid)
-        if sess:
-            # prepare request resource to vim instance
-            req_resouce = "v2.0/ports"
-
-            port = request.data
-            #handle ip and subnetId
-            tmpip = port.pop("ip", None)
-            tmpsubnet = port.pop("subnetId", None)
-            if tmpip and tmpsubnet:
-                 fixed_ip = {
-                    "ip_address": tmpip,
-                    "subnet_id": tmpsubnet,
-                 }
-                 port["fixed_ips"] = []
-                 port["fixed_ips"].append(fixed_ip)
-
-            VimDriverUtils.replace_key_by_mapping(port,
-                                                  self.keys_mapping, True)
-            req_body = json.JSONEncoder().encode({"port": port})
-            resp = sess.post(req_resouce, data=req_body,
-                             endpoint_filter=self.service)
-            resp_body = resp.json()["port"]
-            #use only 1 fixed_ip
-            tmpips = resp_body.pop("fixed_ips", None)
-            if tmpips and len(tmpips) > 0:
-                resp_body.update(tmpips[0])
-
-            VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping)
-            vim_dict = {
-                "vimName": vim["name"],
-                "vimId": vim["vimId"],
-                "tenantId": tenantid,
-                "returnCode": 1,
-            }
-            resp_body.update(vim_dict)
-            return Response(data=resp_body, status=resp.status_code)
-        return {}
-
-    def delete(self, request, vimid="", tenantid="", portid=""):
-        logger.debug("Ports--delete::> %s" % request.data)
-        try:
-            # prepare request resource to vim instance
-            req_resouce = "v2.0/ports"
-            if portid:
-                req_resouce += "/%s" % portid
-#            query = VimDriverUtils.get_query_part(request)
-#            if query:
-#                req_resouce += "?%s" % query
-
-            vim = VimDriverUtils.get_vim_info(vimid)
-            sess = VimDriverUtils.get_session(vim, tenantid)
-            resp = sess.delete(req_resouce, endpoint_filter=self.service)
-            return Response(status=resp.status_code)
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return Response(data=e.response.json(), status=e.http_status)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
diff --git a/newton/pom.xml b/newton/pom.xml
index 8ba525e3..091b6519 100644
--- a/newton/pom.xml
+++ b/newton/pom.xml
@@ -31,14 +31,6 @@
     <packaging>pom</packaging>
     <name>multicloud/openstack/newton</name>
     <description>multicloud for openstack newton</description>
-    <dependencies>
-        <dependency>
-            <groupId>org.onap.multicloud.openstack</groupId>
-            <artifactId>multicloud-openstack-newton</artifactId>
-            <version>1.1.0</version>
-            <type>zip</type>
-        </dependency>
-    </dependencies>
     <properties>
         <encoding>UTF-8</encoding>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>