examples/xapp_symptomdata.py

#!/usr/bin/env python3
# ==================================================================================
#       Copyright (c) 2022 Nokia
#
#   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 os
import sys
import time
import json
import logging
import datetime
import argparse
import threading
import http.server
import signal
import struct
import socket
import urllib.parse
from io import open
from time import gmtime, strftime

#sys.path.insert(0, '../ricxappframe/xapp-frame-py')
from ricxappframe.xapp_frame import RMRXapp, rmr
from ricxappframe.xapp_sdl import SDLWrapper
from ricxappframe.xapp_symptomdata import Symptomdata

# rmr init mode - when set to port 4561 then will wait for the rtmgr to connect
# otherwise will connect to rtmgr like set below
RMR_INIT_SVC = b"4560"
MRC = None
xapp = None

def signal_handler(sig, frame):
    global server
    global MRC
    
    server.stop()
    rmr.rmr_close(MRC)
    sys.exit(0)


def RMR_init_xapp(initbind):
    global RMR_INIT_SVC
    # Init rmr
    MRC = mrc = rmr.rmr_init(initbind, rmr.RMR_MAX_RCV_BYTES, 0x00)
    while rmr.rmr_ready(mrc) == 0:
        time.sleep(1)
        print('[%d]::RMR not yet ready')
    rmr.rmr_set_stimeout(mrc, 1)
    sbuf = rmr.rmr_alloc_msg(mrc, 500)
    rmr.rmr_set_vlevel(5)
    print('[%d]::RMR ready')
    return mrc, sbuf

def read_file(filename):
    try:
        with open(filename, 'r') as f:
            data = f.read()
            if len(data) == 0:
                return None
            return data
    except IOError as error:
        return None

def getSymptomData(symptomHndl, uriparams):
    paramlist = urllib.parse.parse_qs(uriparams)
    [x.upper() for x in paramlist]
    fromtime = 0
    totime = 0
    print(paramlist)
    if paramlist.get('fromTime'):
        fromtime = getSeconds(paramlist.get('fromTime')[0])
    if paramlist.get('toTime'):
        totime = getSeconds(paramlist.get('toTime')[0])
    zipfile = symptomHndl.collect("symptomdata"+'-%Y-%m-%d-%H-%M-%S.zip', ('examples/.*.py',), fromtime, totime)
    if zipfile != None:
        (zipfile, size, data) = symptomHndl.read()
        return (zipfile, size, data)
    return (None, 0, None)


class RestHandler(http.server.BaseHTTPRequestHandler):
    # responds to http request according to the process status
    global symptomHndl
    
    def _set_headers(self, status, length=0, ctype = 'application/json', attachment = None):
        self.send_response(status)
        self.send_header("Server-name", "XAPP REST SERVER 1.0")
        self.send_header('Content-type', ctype)
        if length != 0:
            self.send_header('Content-length', length)
        if attachment != None:
            self.send_header('Content-Disposition', "attachment; filename=" + attachment)
        self.end_headers()
        
    def do_HEAD(self):
        self._set_headers()
        
    def do_POST(self):
        try:
            logging.debug("POST %s" % (self.path))
        except (socket.error, IOError):
            pass

    def do_DELETE(self):
        try:
            logging.debug("DELETE %s" % (self.path))
        except (socket.error, IOError):
            pass


    def do_GET(self):
        # default get handler
        try:
            data = None
            mode = 'plain'
            ctype = 'application/json'
            attachment = None
            if self.path == "/ric/v1/health/alive":
                data = json.dumps({'status': 'alive'})
            elif self.path == "/ric/v1/health/ready":
                data = json.dumps({'status': 'ready'})
            elif self.path.find("/ric/v1/symptomdata") >= 0:
                (zipfile, size, data) = getSymptomData(symptomHndl, self.path[20:])
                if data != None:
                    mode = 'binary'
                    ctype = 'application/zip'
                    attachment = "symptomdata.zip"
                else:
                    logging.error("Symptom data does not exists")
                    self._set_headers(404, 0)
                
            if data is not None:
                length = len(data)
                self._set_headers(200, length, ctype, attachment)
                if mode == 'plain':
                    # ascii mode
                    self.wfile.write(data.encode('utf-8'))
                else:
                    # binary mode
                    self.wfile.write(data)
            else:
                logging.error("Unknown uri %s" % (self.path))
                self._set_headers(404, 0)
        except (socket.error, IOError):
            pass
 
class ThreadedHTTPServer(object):
    handler = RestHandler
    server_class = http.server.HTTPServer
    def __init__(self, host, port):
        self.server = self.server_class((host, port), self.handler)
        self.server_thread = threading.Thread(target=self.server.serve_forever)
        self.server_thread.daemon = True

    def start(self):
        self.server_thread.start()

    def stop(self):
        self.server.socket.close()
        self.server.server_close()
        self.server.shutdown()

def main():
    global server
    global xapp
    global symptomHndl
    
    # init the default values
    ADDRESS = "0.0.0.0"     # bind to all interfaces
    PORT = 8080             # web server listen port
    
    parser = argparse.ArgumentParser()
    parser.add_argument('-port', dest='port', help='HTTP server listen port, default 3000', required=False, type=int)
    parser.add_argument('-address', dest='address', help='IP listen address, default all interfaces', required=False, type=str)
    parser.add_argument('-xapp', dest='xapp', help='xapp name', required=True, type=str)
    parser.add_argument('-service', dest='service', help='xapp service name (same as pod host name)', required=True, type=str)
    args = parser.parse_args()
    
    if args.port is not None:
        PORT = args.port
    if args.address is not None:
        ADDRESS = args.address

    # handle the RMR_SEED_RT and RMR_RTG_SVC which is different in mcxapp
    data = None
    os.environ["RMR_SRC_ID"] = args.service
    os.environ["RMR_LOG_VLEVEL"] = '4'
    os.environ["RMR_RTG_SVC"] = "4561"
    rmrseed = os.environ.get('RMR_SEED_RT')
    if rmrseed is not None:
        data = read_file(rmrseed)
        if data is None:
            print("RMR seed file %s does not exists or is empty" % (rmrseed))
    else:
        print("RMR_SEED_RT seed file not set in environment")
        data = read_file('uta-rtg.rt')
        if data is not None:
            os.environ['RMR_SEED_RT'] = "./uta-rtg.rt"
            print("Setting the default RMR_SEED_RT=uta-rtg.rt - content:")
            print(data)
        else:
            print("Try to export the RMR_SEED_RT file if your RMR is not getting ready")

    symptomHndl = Symptomdata(args.service, args.xapp, "/tmp/", "http://service-ricplt-lwsd-http:8080/ric/v1/lwsd", 10)
    
    # Start the threaded server, bind to address
    server = ThreadedHTTPServer(ADDRESS, PORT)
    server.start()

    mrc, sbuf = RMR_init_xapp(b"4560")

    while True:
        print("Waiting for a message, will timeout after 2000ms")
        sbuf = rmr.rmr_torcv_msg(mrc, None, 2000)
        summary = rmr.message_summary(sbuf)
        if summary[rmr.RMR_MS_MSG_STATE] == 12:
            print("Nothing received =(")
        else:
            print("Message received!: {}".format(summary))
            data = rmr.get_payload(sbuf)
        rmr.rmr_free_msg(sbuf)

if __name__ == '__main__':
    signal.signal(signal.SIGQUIT, signal_handler)
    signal.signal(signal.SIGTERM, signal_handler)
    signal.signal(signal.SIGINT, signal_handler)
    main()