Move openoapi from newton to newton_base

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

13 files changed, 2136 insertions, 9 deletions

diff --git a/ocata/ocata/requests/urls.py b/ocata/ocata/requests/urls.py
index 69f0e444..77e2c200 100644
--- a/ocata/ocata/requests/urls.py
+++ b/ocata/ocata/requests/urls.py
@@ -15,15 +15,15 @@
 from django.conf.urls import url
 from rest_framework.urlpatterns import format_suffix_patterns
 
-from newton.requests.views import network
-from newton.requests.views import subnet
-from newton.requests.views import image
-from newton.requests.views import volume
-from newton.requests.views import server
-from newton.requests.views import vport
-from newton.requests.views import limits
-from newton.requests.views import hosts
-from newton.requests.views import flavor
+from newton_base.openoapi import network
+from newton_base.openoapi import subnet
+from newton_base.openoapi import image
+from newton_base.openoapi import volume
+from newton_base.openoapi import server
+from newton_base.openoapi import vport
+from newton_base.openoapi import limits
+from newton_base.openoapi import hosts
+from newton_base.openoapi import flavor
 
 urlpatterns = [
     url(r'^networks(/(?P<networkid>[0-9a-zA-Z_-]+))?',
diff --git a/share/newton_base/openoapi/__init__.py b/share/newton_base/openoapi/__init__.py
new file mode 100644
index 00000000..802f3fba
--- /dev/null
+++ b/share/newton_base/openoapi/__init__.py
@@ -0,0 +1,10 @@
+# Copyright (c) 2017 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.
diff --git a/share/newton_base/openoapi/flavor.py b/share/newton_base/openoapi/flavor.py
new file mode 100644
index 00000000..27bbb821
--- /dev/null
+++ b/share/newton_base/openoapi/flavor.py
@@ -0,0 +1,345 @@
+# 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_base.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/share/newton_base/openoapi/hosts.py b/share/newton_base/openoapi/hosts.py
new file mode 100644
index 00000000..720ba8e2
--- /dev/null
+++ b/share/newton_base/openoapi/hosts.py
@@ -0,0 +1,85 @@
+# Copyright (c) 2017 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_base.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/share/newton_base/openoapi/image.py b/share/newton_base/openoapi/image.py
new file mode 100644
index 00000000..9ddb5f55
--- /dev/null
+++ b/share/newton_base/openoapi/image.py
@@ -0,0 +1,235 @@
+# Copyright (c) 2017 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_base.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/share/newton_base/openoapi/limits.py b/share/newton_base/openoapi/limits.py
new file mode 100644
index 00000000..3f62afa3
--- /dev/null
+++ b/share/newton_base/openoapi/limits.py
@@ -0,0 +1,82 @@
+# Copyright (c) 2017 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_base.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/share/newton_base/openoapi/network.py b/share/newton_base/openoapi/network.py
new file mode 100644
index 00000000..a1ac550d
--- /dev/null
+++ b/share/newton_base/openoapi/network.py
@@ -0,0 +1,171 @@
+# Copyright (c) 2017 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_base.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/share/newton_base/openoapi/server.py b/share/newton_base/openoapi/server.py
new file mode 100644
index 00000000..c53e43e8
--- /dev/null
+++ b/share/newton_base/openoapi/server.py
@@ -0,0 +1,426 @@
+# Copyright (c) 2017 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_base.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/share/newton_base/openoapi/subnet.py b/share/newton_base/openoapi/subnet.py
new file mode 100644
index 00000000..1310ab50
--- /dev/null
+++ b/share/newton_base/openoapi/subnet.py
@@ -0,0 +1,169 @@
+# Copyright (c) 2017 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_base.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/share/newton_base/openoapi/tenants.py b/share/newton_base/openoapi/tenants.py
new file mode 100644
index 00000000..bcd8f2f2
--- /dev/null
+++ b/share/newton_base/openoapi/tenants.py
@@ -0,0 +1,85 @@
+# Copyright (c) 2017 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_base.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/share/newton_base/openoapi/volume.py b/share/newton_base/openoapi/volume.py
new file mode 100644
index 00000000..a048dda4
--- /dev/null
+++ b/share/newton_base/openoapi/volume.py
@@ -0,0 +1,168 @@
+# Copyright (c) 2017 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_base.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/share/newton_base/openoapi/vport.py b/share/newton_base/openoapi/vport.py
new file mode 100644
index 00000000..8f9b0d62
--- /dev/null
+++ b/share/newton_base/openoapi/vport.py
@@ -0,0 +1,202 @@
+# Copyright (c) 2017 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_base.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/share/newton_base/util.py b/share/newton_base/util.py
new file mode 100644
index 00000000..d2363252
--- /dev/null
+++ b/share/newton_base/util.py
@@ -0,0 +1,149 @@
+# Copyright (c) 2017 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)