Remove guest monitor function from TC

Change-Id: I17f129ab42b931dd4097cb9106e2fa7423df89ea
Issue-ID: MULTICLOUD-183
Signed-off-by: Yun Huang <yun.huang@windriver.com>

1 files changed, 0 insertions, 321 deletions

diff --git a/windriver/titanium_cloud/extensions/views/fcaps.py b/windriver/titanium_cloud/extensions/views/fcaps.py
deleted file mode 100644
index a093a361..00000000
--- a/windriver/titanium_cloud/extensions/views/fcaps.py
+++ /dev/null
@@ -1,321 +0,0 @@
-# Copyright (c) 2017-2018 Wind River Systems, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import logging
-import json
-import traceback
-import threading
-
-from django.core.cache import cache
-
-from keystoneauth1.exceptions import HttpError
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-from django.conf import settings
-from common.exceptions import VimDriverNewtonException
-from newton_base.util import VimDriverUtils
-from common.msapi import extsys
-
-
-
-#from newton.extensions.views import fcaps as newton_fcaps
-
-logger = logging.getLogger(__name__)
-
-# DEBUG=True
-
-#dict to store running worker threads
-running_threads = {}
-running_thread_lock = threading.Lock()
-
-class GuestMonitorWorker (threading.Thread):
-    service = {'service_type': 'platform',
-               'interface': 'public'}
-    def __init__(self, vimid, tenantid=None):
-        threading.Thread.__init__(self)
-        self.vimid = vimid
-        self.tenantid = tenantid
-        self.eventid = '700.213' #Guest Heartbeat failed for instance
-
-    def run(self):
-        logger.debug("start GuestMonitorWorker %s,%s" % (self.vimid, self.tenantid))
-
-        viminfo = VimDriverUtils.get_vim_info(self.vimid)
-        sess = VimDriverUtils.get_session(viminfo, tenantid=self.tenantid)
-
-        thread_info = running_threads.get(self.vimid)
-        if not thread_info:
-            return
-
-        while thread_info.get('state') == 'start':
-            #wait for jobs
-            vservers = thread_info.get('vservers') if thread_info else None
-            if not vservers:
-                continue
-
-            # do jobs
-            for (vserverid, vserverinfo) in vservers.items():
-                status_code, heartbeat_event = \
-                    self.monitor_heartbeat(self.vimid, self.tenantid, vserverid, viminfo, sess)
-
-                if status_code == status.HTTP_403_FORBIDDEN:
-                    #invalid tenant, so remove this job
-
-                    running_thread_lock.acquire()
-                    thread_info['state'] = 'error'
-                    running_thread_lock.release()
-
-                    return #exit this thread since error
-
-                if heartbeat_event:
-                    #report to VES
-                    #tbd
-                    pass
-                else:
-                    continue
-
-        running_thread_lock.acquire()
-        thread_info['state'] = 'stopped'
-        running_thread_lock.release()
-
-        logger.debug("stop GuestMonitorWorker %s, %s, %s" % (self.vimid, self.tenantid, self.vserverid))
-#        running_thread_lock.acquire()
-#        running_threads.pop(self.vimid)
-#        running_thread_lock.release()
-
-    def monitor_heartbeat(self, vimid, tenantid, vserverid, viminfo, session):
-        logger.debug("GuestMonitorWorker--monitor_heartbeat::> %s" % (vserverid))
-        try:
-            # prepare request resource to vim instance
-            req_resouce = "/v1/event_log?q.field=entity_instance_id&\
-                q.field=event_log_id&\
-                q.op=eq&q.op=eq&q.type=&q.type=&\
-                q.value=tenant\%%s.instance\%%s&\
-                q.value=%s" % (tenantid, vserverid, self.eventid)
-
-            resp = session.get(req_resouce, endpoint_filter=self.service,
-                    headers={"Content-Type": "application/json",
-                             "Accept": "application/json"})
-
-            logger.debug("response status code of monitor_heartbeat %s" % resp.status_code)
-
-            return resp.status_code, resp.json() if resp.content else None
-
-        except HttpError as e:
-            logger.error("monitor_heartbeat, HttpError: status:%s, response:%s" % (e.http_status, e.response.json()))
-            return e.http_status, e.response.json()
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            logger.error("Failed to monitor_heartbeat:%s" % str(e))
-            return e.http_status, e.response.json()
-
-
-class GuestMonitor(APIView):
-
-    def __init__(self):
-        self.proxy_prefix = settings.MULTICLOUD_PREFIX
-        self._logger = logger
-
-    def post(self, request, vimid="", vserverid=""):
-        '''Start guest monitoring on specified virtual server'''
-        self._logger.debug("GuestMonitor--post::data> %s" % request.data)
-        self._logger.debug("GuestMonitor--post::vimid > %s" % vimid)
-
-        try:
-            # populate proxy identity url
-            cloud_owner, cloud_region_id = extsys.decode_vim_id(vimid)
-
-            tenant_name = request.data.get('tenantName')
-            tenant_id = request.data.get('tenantID')
-            ves_url = request.data.get('vesurl')
-
-            # prepare request resource to vim instance
-            # get token:
-            viminfo = VimDriverUtils.get_vim_info(vimid)
-            # the tenant should have the privilege to access the event-log API
-            # usually it is 'admin'. Otherwise the 403 will be returned.
-            sess = None
-            if tenant_id:
-                sess = VimDriverUtils.get_session(viminfo, tenantid=tenant_id)
-            else:
-                sess = VimDriverUtils.get_session(viminfo, tenantname=tenant_name)
-
-            #now try to convert tenant_name to tenant_id
-            #tbd
-
-            thread_info = running_threads[vimid]
-
-            if thread_info and  thread_info['state'] == 'error':
-                #the thread is in error state, so recreate with new tenant_id
-                running_thread_lock.acquire()
-                running_threads.pop(vimid)
-                running_thread_lock.release()
-                thread_info = None
-
-            if not thread_info:
-                tmp_thread = GuestMonitorWorker(vimid, tenant_id)
-                if not tmp_thread:
-                    raise VimDriverNewtonException(message="internal error",
-                                               content="Fail to spawn thread for Guest Monitoring",
-                                               status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
-                thread_info = {
-                    'thread': tmp_thread,
-                    'tenantid':tenant_id,
-                    'vservers':{},
-                    'state':'start'
-                }
-
-                running_thread_lock.acquire()
-                running_threads[vimid] = thread_info
-                running_thread_lock.release()
-                tmp_thread.start()
-            else:
-                thread_info['state'] = 'start'
-
-
-            vservers = thread_info.get('vservers')
-            vservers[vserverid] = {'vesurl': ves_url}
-
-            return Response(status=status.HTTP_202_ACCEPTED)
-
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            self._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:
-            self._logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-    def GET(self, request, vimid="", vserverid=""):
-        '''query guest monitoring on specified virtual server'''
-        self._logger.debug("GuestMonitor--get::data> %s" % request.data)
-        self._logger.debug("GuestMonitor--get::vimid > %s" % vimid)
-
-        try:
-            # populate proxy identity url
-            cloud_owner, cloud_region_id = extsys.decode_vim_id(vimid)
-
-            tenant_name = request.data.get('tenantName')
-            tenant_id = request.data.get('tenantID')
-            vserver_id = vserverid
-
-            # prepare request resource to vim instance
-            # get token:
-            viminfo = VimDriverUtils.get_vim_info(vimid)
-            # the tenant should have the privilege to access the event-log API
-            # usually it is 'admin'. Otherwise the 403 will be returned.
-            sess = None
-            if tenant_id:
-                sess = VimDriverUtils.get_session(viminfo, tenantid=tenant_id)
-            else:
-                sess = VimDriverUtils.get_session(viminfo, tenantname=tenant_name)
-
-            #now try to convert tenant_name to tenant_id, and vserver_name to vserver_id
-            #tbd
-
-            thread_info = running_threads[vimid]
-            if not thread_info \
-                    or not thread_info.get('vservers') \
-                    or not thread_info.get('vservers').get(vserverid):
-                status_code = status.HTTP_204_NO_CONTENT
-                content = {'error':
-                               'Guest Monitor job is not created for this virtual server,\
-                               vim id: %s, vserver id: %s'
-                               % (self.vimid,  vserverid)}
-                pass
-            elif thread_info['state'] == 'error':
-                status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
-                content = {'error':
-                               'Guest Monitor job for this virtual server \
-                               (vim id: %s, vserver id: %s) failed due to: %s'
-                               % (self.vimid,  vserverid, thread_info.get('message'))}
-                pass
-            else:
-                vserverinfo = thread_info.get('vservers').get(vserverid)
-                content = vserverinfo.get('message')
-                status_code = vserverinfo.get('status') or status.HTTP_200_OK
-                pass
-
-            #return Response(status=status.HTTP_202_ACCEPTED)
-            return Response(status=status_code, data=content)
-
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            self._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:
-            self._logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-
-    def DELETE(self, request, vimid="", vserverid=""):
-        '''Stop guest monitoring on specified virtual server'''
-        self._logger.debug("GuestMonitor--delete::data> %s" % request.data)
-        self._logger.debug("GuestMonitor--delete::vimid > %s" % vimid)
-
-        try:
-            # populate proxy identity url
-            cloud_owner, cloud_region_id = extsys.decode_vim_id(vimid)
-
-            tenant_name = request.data.get('tenantName')
-            tenant_id = request.data.get('tenantID')
-
-            # prepare request resource to vim instance
-            # get token:
-            viminfo = VimDriverUtils.get_vim_info(vimid)
-            # the tenant should have the privilege to access the event-log API
-            # usually it is 'admin'. Otherwise the 403 will be returned.
-            sess = None
-            if tenant_id:
-                sess = VimDriverUtils.get_session(viminfo, tenantid=tenant_id)
-            else:
-                sess = VimDriverUtils.get_session(viminfo, tenantname=tenant_name)
-
-            #now try to convert tenant_name to tenant_id, and vserver_name to vserver_id
-            #tbd
-
-            thread_info = running_threads[vimid]
-            if not thread_info:
-                status_code = status.HTTP_204_NO_CONTENT
-            else:
-                vservers = thread_info.get('vservers')
-                if vservers.get(vserverid):
-                    vservers.pop(vserverid)
-
-                running_thread_lock.acquire()
-                if len(vservers.items()) == 0:
-                    thread_info.stop()
-                    running_threads.pop(vimid)
-                running_thread_lock.release()
-                status_code = status.HTTP_202_ACCEPTED
-
-            return Response(status=status_code)
-
-        except VimDriverNewtonException as e:
-            return Response(data={'error': e.content}, status=e.status_code)
-        except HttpError as e:
-            self._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:
-            self._logger.error(traceback.format_exc())
-            return Response(data={'error': str(e)},
-                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)