serverWsgi.michel.py

#!/usr/bin/env python

from bottle import route, run, get, request, view, default_app, response, error

import astropy

import sys
import socket
import getopt
import os
import traceback
import collections
import numpy as np

import json
import errno
import logging
from autologging import logged, TRACE, traced

ARTEMIXDataDir = None
FITSRootDir = None
SAMPDataDir = None
baseUrl = "/artemix"

logger = None
dm = None

import dataManager_michel as dataManager

#####################################################################
#                                                                   #
#                            Utilities                              #
#                                                                   #
#####################################################################

"""
enable cross domain ajax requests
"""
def enable_cors(fn):
    def _enable_cors(*args, **kwargs):
    # set CORS headers
        response.headers['Access-Control-Allow-Origin'] = '*'
        response.headers['Access-Control-Allow-Methods'] = 'GET, POST, PUT, OPTIONS'
        response.headers['Access-Control-Allow-Headers'] = 'Origin, Accept, Content-Type, X-Requested-With, X-CSRF-Token'

        if request.method != 'OPTIONS':
            # actual request; reply with the actual response
            return fn(*args, **kwargs)

    return _enable_cors

def getFloatValue(value):
    if value is not None and str(value) != "null":
        return float(value)
    return None

def getIntValue(value):
    if value is not None and str(value) != "null":
        return int(value)
    return None

def getBoolValue(value):
    if value is not None and str(value) != "null":
        return value == "true"
    return None

"""
	Replaces NaN values by None in array
"""
def cleanNanInList(arr):
    result = arr
    result[np.isnan(result)] = None
    return result

"""
    Given filename ( string )
    returns a string where each space character present in filename is replaced by '+' character.
"""
def rebuildFilename(filename):
    result = byteify(filename.replace(" ", "+"))
    if ((result[0] == '"' and result[len(result) - 1] == '"') or ( result[0] == "'" and result[len(result) - 1] == "'" )):
        result = result[1:-1]
    return result

"""
    A function to transform the content of a dictionary a unicode value into its ascii's
    see https://stackoverflow.com/questions/956867/how-to-get-string-objects-instead-of-unicode-from-json
"""

def byteify(input):
    result = None
    if isinstance(input, dict):
        result = {byteify(key): byteify(value)
                for key, value in input.items()}
    elif isinstance(input, list):
        result = [byteify(element) for element in input]
    elif isinstance(input, str):
        result =  input.encode('utf-8').decode('utf-8')
    elif isinstance(input, bytes):
        result = input.encode('utf-8').decode('utf-8')
    else:
        result = input
    #logging.debug("result = %r" % result)
    return result


#####################################################################
#                                                                   #
#                   Routes definitions                              #
#                                                                   #
#####################################################################

"""
  Check that the server is alive and waiting.
"""
@route(baseUrl+"/ping", name='upAnWaiting', method='GET')
@enable_cors
def upAnWaiting():
  logger.debug("upAndWaiting - wrapper : entering")
  logger.debug("upAndWaiting - wrapper : exiting")
  return "{status: %r, message : 'Up and waiting', 'result': %r}" % (True, request)

"""
    Given two values expressed in degrees one for a Right Ascension (ra) and one for a Declination
    returns their respectives conversion in Hour Minute Second and Degree Minute Second
"""
@route( baseUrl+'/degToHMSDMS', name='degToHMSDMS', method='GET')
@enable_cors
def degToHMSDMS():
    logger.debug("degToHMSDMS - wrapper : entering")
    try:
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
        RAinDD = getFloatValue(request.GET['RAinDD'])
        DECinDD = getFloatValue(request.GET['DECinDD'])
    except Exception as e:
        logger.debug(f'{e}')
        raise

    response.content_type = "application/json; charset=utf-8"
    logger.debug("degToHMSDMS - wrapper : exiting")

    return json.dumps(dm.degToHMSDMS(relFITSFilePath, RAinDD, DECinDD))


"""
    Given a FITS filename and an interval of positive integers values and
    an integer step returns an array of Hour:Minute:Second right ascension values
    located on the grid defined by (start, end, step)
"""
@route( baseUrl+'/rangeToHMS', name='rangeToHMS', method='GET')
@enable_cors
def rangeToHMS():
    logger.debug("rangeToHMS - wrapper : entering")
    try:
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
        iRA0 = getIntValue(request.GET['iRA0'])
        iRA1 = getIntValue(request.GET['iRA1'])
        iRAstep = getIntValue(request.GET['iRAstep'])
    except Exception as e:
        logger.debug(f'{e}')
        raise

    response.content_type = "application/json; charset=utf-8"
    logger.debug("rangeToHMS - wrapper : exiting")

    return json.dumps(dm.rangeToHMS(relFITSFilePath, iRA0, iRA1, iRAstep))

"""
    Given a FITS filename and an interval of positive integers values and
    an integer step returns an array of Degree:Minute:Second declination values
    located on the grid defined by (start, end, step)
"""
@route( baseUrl+'/rangeToDMS', name='rangeToDMS', method='GET')
@enable_cors
def rangeToDMS():
    logger.debug("rangeToDMS - wrapper : entering")
    try:
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
        iDEC0 = getIntValue(request.GET['iDEC0'])
        iDEC1 = getIntValue(request.GET['iDEC1'])
        iDECstep = getIntValue(request.GET['iDECstep'])
    except Exception as e:
        logger.debug(f'{e}')
    response.content_type = "application/json; charset=utf-8"
    logger.debug("rangeToDMS - wrapper : exiting")

    return json.dumps(dm.rangeToDMS(relFITSFilePath, iDEC0, iDEC1, iDECstep))

"""
    Given relFITSFilePath read corresponding the FITS file in memory
    returns the FITS header of that file.
"""
@route( baseUrl+'/setData', name='setData', method='GET')
@enable_cors
def setData():
    logger.debug("setData - wrapper : entering")
    try:
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
    except Exception as e:
        logger.debug(f'{e}')
        raise
    response.content_type = "application/json; charset=utf-8"
    result = dm.setData(relFITSFilePath)
    logger.debug("setData - wrapper : exiting")
    return json.dumps(result)

"""
    Given filename return the shape of the data cube contained
    in relFITSFilePath
"""
@route( baseUrl+'/getDimensions', name='getDimensions', method='GET')
@enable_cors
def getDimensions():
    logger.debug("getDimensions - wrapper : entering")
    try:
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
    except Exception as e:
        logger.debug(f'{e}')
        raise
    response.content_type = "application/json; charset=utf-8"
    logger.debug("getDimensions - wrapper : exiting")

    return json.dumps(dm.getDimensions(relFITSFilePath))

"""
    Given a multidimensional array l
    return a flattened representation of l
"""
@route( baseUrl+'/flatten', name='flatten', method='GET')
@enable_cors
def flatten():

    l = request.GET['l']

    return json.dumps(dm.flatten(l))

"""
    Given relFITSFilePath and a triple of integer values iFreq, iRA, iDEC
    returns the pixel value with coordinates (iFreq, iRA, iDEC) in the data cube
    associated to relFITSFilePath.
"""
@route( baseUrl+'/getPixelValueAtiFreqiRAiDEC', name="getPixelValueAtiFreqiRAiDEC", method='GET')
@enable_cors
def getPixelValueAtiFreqiRAiDEC():
    logger.debug("getPixelValueAtiFreqiRAiDEC - wrapper : entering" )
    try:
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
        iFREQ = getIntValue(request.GET['iFREQ'])
        iRA = getIntValue(request.GET['iRA'])
        iDEC = getIntValue(request.GET['iDEC'])
        result = json.dumps(dm.getPixelValueAtiFreqiRAiDEC(relFITSFilePath, iFREQ, iRA, iDEC))
    except Exception as e:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        traceback.print_exc()
        message = "%s ! %s" %  (repr(e), "".join(traceback.format_list(traceback.extract_tb(exc_traceback))))
        result = {"status": False, "message": message}

    response.content_type = "application/json; charset=utf-8"
    logger.debug("getPixelValueAtiFreqiRAiDEC - wrapper : exiting" )
    return result

"""
    Given an integer sliceNumb and an integer step
    and a string relFITSFilePath
    returns a 2D array made of one pixel every (step, step)
    of the slice sliceNumb in the datacube contained in relFITSFilePath
"""
@route( baseUrl+'/getSlice', name='getSlice', method='GET')
@enable_cors
def getSlice():
    logger.debug("getSlice - wrapper : entering" )

    try:
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
        iFREQ = int(request.GET['iFREQ'])
    except Exception as e:
        logger.debug(f'{e}')
        raise

    result = dm.getSlice(relFITSFilePath, iFREQ)
    response.content_type = "application/json; charset=utf-8"
    logger.debug("getSlice - wrapper : exiting" )

    return json.dumps(result)

"""
    Given one pair, x and y, of integer coordinates in the RAxDEC plane and
    a frequency range defined by a pair of integers iFREQ0 and iFRE1
    returns the values contained in the data cube at [iFREQ0:iFRE1, x, y]
"""
@route( baseUrl+'/getFreq', name='getFreq', method='GET')
@enable_cors
def getFreq():
    logger.debug("getFreq - wrapper : entering" )

    try:
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
        iRA = getIntValue(request.GET['iRA'])
        iDEC = getIntValue(request.GET['iDEC'])
        iFREQ0 = getIntValue(request.GET['iFREQ0'])
        iFREQ1 = getIntValue(request.GET['iFREQ1'])
    except Exception as e:
        logger.debug(f'{e}')
        raise
    response.content_type = "application/json; charset=utf-8"
    result = json.dumps(dm.getFreq(relFITSFilePath, iRA, iDEC, iFREQ0, iFREQ1))
    logger.debug("getFreq - wrapper : exiting")

    return result

"""
    Given two pairs -- iRA0,iRA1 and iDEC0,iDEC1 -- defining a rectangular area the RAxDEC plane
    and a frequency range defined by a pair of integers iFREQ0 and iFRE1
    returns the result of numpy.nansum(datacube[iFREQ0:iFRE1, iDEC0:iDEC1, iRA0:iRA1], (1,2))
    multiplied by cdelt and divided by convert where

    * cdelt == 4 * math.log(2) * abs(CDELT1) * pi180 * abs(CDELT2) * pi180
    * convert == pi * bmaj * bmin
    * bmaj == BMAJ * pi180
    * bmin == BMIN * pi180
    * pi180 == pi / 180 / 4.86e-6

    That is a weighted sum the defined area of the data cube along the frequency axis.
"""
@route( baseUrl+'/getAverageSpectrum', name='getAverageSpectrum', method='GET')
@enable_cors
def getAverageSpectrum():
    logger.debug("getAverageSpectrum - wrapper : entering" )

    relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])

    try:
        iDEC0 = getIntValue(request.GET['iDEC0'])
        iDEC1 = getIntValue(request.GET['iDEC1'])
        iRA0 = getIntValue(request.GET['iRA0'])
        iRA1 = getIntValue(request.GET['iRA1'])
        retFITS = getBoolValue(request.GET['retFITS'])
    except Exception as e:
        logger.debug(f'{e}')
        raise

    response.content_type = "application/json; charset=utf-8"
    result = json.dumps(dm.getAverageSpectrum(relFITSFilePath, iDEC0, iDEC1, iRA0, iRA1, retFITS))
    logger.debug("getAverageSpectrum - wrapper : exiting" )

    return result

"""
    Given two pairs -- RAPix0,RAPix1 and DECPix0,DECPix1 -- defining a rectangular area the RAxDEC plane
    and a frequency defined by an integer iFREQ
    returns the result of numpy.nansum(datacube[iFREQ, iDEC0:iDEC1, iRA0:iRA1], (1,2))
    multiplied by 4 * log(2) * cdelt1 * pi / 180 / 4.86e-6 * cdelt2 * pi / 180 / 4.86e-6
"""
@route( baseUrl+'/getSumOverSliceRectArea', name='getSumOverSliceRectArea', method='GET')
@enable_cors
def getSumOverSliceRectArea():
    logger.debug("getSumOverSliceRectArea - wrapper : entering" )
    try:
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
        DECPix0 = getIntValue(request.GET['DECPix0'])
        DECPix1 = getIntValue(request.GET['DECPix1'])
        RAPix0 = getIntValue(request.GET['RAPix0'])
        RAPix1 = getIntValue(request.GET['RAPix1'])
        iFREQ = getIntValue(request.GET['iFREQ'])
    except Exception as e:
        logger.debug(f'{e}')
        raise

    response.content_type = "application/json; charset=utf-8"
    result = json.dumps(dm.getSumOverSliceRectArea(relFITSFilePath,  iFREQ, RAPix0, RAPix1, DECPix0, DECPix1))
    logger.debug("getSumOverSliceRectArea - wrapper : exiting" )

    return result

"""
    Given two pairs -- iRA0,iRA1 and iDEC0,iDEC1 -- defining a rectangular area the RAxDEC plane
    and a frequency range defined by a pair of integers iFREQ0 and iFRE1
    returns the result of numpy.nansum(datacube[iFREQ0:iFRE1, iDEC0:iDEC1, iRA0:iRA1], 0)
    multiplied by 4 * log(2) * cdelt1 * pi / 180 / 4.86e-6 * cdelt2 * pi / 180 / 4.86e-6
"""
@route( baseUrl+'/getAverage', name='getAverage', method='GET')
@enable_cors
def getAverage():
    logger.debug("getAverage - wrapper : entering" )
    try:
        logger.debug(request)
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
        iDEC0 = getIntValue(request.GET['iDEC0'])
        iDEC1 = getIntValue(request.GET['iDEC1'])
        iRA1 = getIntValue(request.GET['iRA1'])
        iRA0 = getIntValue(request.GET['iRA0'])
        iFREQ0 = getIntValue(request.GET['iFREQ0'])
        iFREQ1 = getIntValue(request.GET['iFREQ1'])
        retFITS = getBoolValue(request.GET['retFITS'])
        result = dm.getAverage(relFITSFilePath, iFREQ0, iFREQ1, iDEC0, iDEC1, iRA0, iRA1, retFITS)
    except Exception as e:
        logger.debug(f'{e}')
        exc_type, exc_value, exc_traceback = sys.exc_info()
        message = "%s ! %s" %  (type(e), "".join(traceback.format_list(traceback.extract_tb(exc_traceback))))
        traceback.print_exc()
        result = {"status": False, "message": message}
    response.content_type = "application/json; charset=utf-8"
    logger.debug("getAverage - wrapper : exiting" )
    return json.dumps(result)

"""
Create a FITS file whose type is TABLE and content is the spectrum at position (iRA, iDEC)
along with the frequencies/velocities.

Returns the content of the file.
"""
# @route( baseUrl+'/createFits', name='createFits', method='POST')
# @enable_cors
# def createFits():
#     logger.debug("createFits - wrapper : entering" )
#     try:
#         header = request.json['header']
#         relFITSFilePath = request.json['relFITSFilePath']
#         iRA = request.json['iRA']
#         iDEC = request.json['iDEC']
#     except Exception as e:
#         logger.debug(f'{e}')
#         raise
#     response.content_type = "application/json; charset=utf-8"
#     logger.debug("createFits - wrapper : exiting" )
#     return json.dumps(dm.createFits(relFITSFilePath, iRA, iDEC))

"""
    Given relFITSFilePath
    returns the FITS header
"""
@route( baseUrl+'/getHeader', name='getHeader', method='GET')
@enable_cors
def getHeader():
    logger.debug("getHeader - wrapper : entering")
    try:
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
    except Exception as e:
        logger.debug(f'{e}')
        raise
    response.content_type = "application/json; charset=utf-8"
    result = json.dumps(dm.getHeader(relFITSFilePath))
    logger.debug("getHeader - wrapper : exiting")
    return result

"""
    Given relFITSFilePath
    returns the area in the RA x DEC plane of the data contained in the data cube
    as a pair of pairs ((ramin, ramax), ( decmin, decmax))
"""
@route( baseUrl+'/RADECRangeInDegrees', name='RADECRangeInDegrees', method='GET')
@enable_cors
def RADECRangeInDegrees():
    logger.debug("RADECRangeInDegrees - wrapper : entering")
    try :
        relFITSFilePath = rebuildFilename(request.GET['relFITSFilePath'])
    except Exception as e:
        logger.debug(f'{e}')
        raise
    response.content_type = "application/json; charset=utf-8"
    logger.debug("RADECRangeInDegrees - wrapper : exiting")

    return json.dumps(dm.RADECRangeInDegrees(relFITSFilePath))

"""
    Given relFITSFilePath and iFREQ

    produces a PNG file representing the slice number int(iFREQ_s) of the datacube along the frequency axis

    returns a dictionary {"data_steps" : data_steps, "path_to_png": relPNGFilePath} where :

    * data_steps is a dictionary color -> physical quantity for a flux density
    * relPNGFilePath a path to the PNG file relative to the root directory of PNG files.
"""
@route( baseUrl+'/getOneSliceAsPNG', name='getOneSliceAsPNG', method='POST')
@enable_cors
def getOneSliceAsPNG():
    request_body = (request.body.read())
    body = None
    response.content_type = "application/json; charset=utf-8"

    try:
        body = byteify(json.loads(request_body))
        relFITSFilePath = rebuildFilename(body['relFITSFilePath'])
        iFREQ = getIntValue(body['iFREQ'])

        kwargs = {}
        for x in ['ittName', 'lutName', 'vmName']:
            if x in body :
                kwargs[x]=body[x]
        ret = dm.getOneSliceAsPNG(iFREQ, relFITSFilePath, **kwargs)
    except Exception as e:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        traceback.print_exc()
        message = "%s ! %s" %  (repr(e), "".join(traceback.format_list(traceback.extract_tb(exc_traceback))))
        ret = {"status": False, "message": message}
    return json.dumps(ret)

"""
    Given relFITSFilePath and a pair iFREQ0, iFREQ1
    performs a weighted sum slices with indices in [iFREQ0, iFREQ1] along the frequency axis
    and saves it as a PNG file.

    returns a dictionary {"data_steps" : data_steps, "path_to_png": relPNGFilePath} where :

    * data_steps is a dictionary color -> physical quantity for a flux density
    * relPNGFilePath a path to the PNG file relative to the root directory of PNG files.
"""
@route( baseUrl+'/getSummedSliceRangeAsPNG', name='getSummedSliceRangeAsPNG', method='POST')
@enable_cors
def getSummedSliceRangeAsPNG():
    response.content_type = "application/json; charset=utf-8"

    try:
        body = byteify(json.loads(request.body.read()))
        logger.debug("getSummedSliceRangeAsPNG(): body = %r" % json.loads(request.body.read()) )
        relFITSFilePath = rebuildFilename(body['relFITSFilePath'])
        iFREQ0 = getIntValue(body['iFREQ0'])
        iFREQ1 = getIntValue(body['iFREQ1'])

        kwargs = {}
        for x in ['ittName', 'lutName', 'vmName']:
            if x in body :
                kwargs[x]=body[x]
        ret =  dm.getSummedSliceRangeAsPNG(relFITSFilePath, iFREQ0, iFREQ1,  **kwargs);
    except Exception as e:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        message = "%s ! %s" %  (type(e), "".join(traceback.format_list(traceback.extract_tb(exc_traceback))))
        traceback.print_exc()
        ret = {"status": False, "message": message}
    return json.dumps(ret)

"""
    Given the values of a spectrum 'ydata' passed with the corresponding frequency values 'xdata'
    at an (x,y) given position ( integer indexes ) in the RAxDEC plan of a cube, generate a FITS file containing that
    spectrum. Supposedly be used for interoperability based on SAMP. A typical interlocutor is CASSIS

    @header the FITS Header of the file contaning the input data cube.
    @relFITSFilePath the path to the input data cube on disk.
    @iRA a single integer value containing the index along the RA axis
    @iDEC a single integer value containing the index along the DEC axis
"""
@route( baseUrl+'/createFits', name='createFits', method='POST')
@enable_cors
def createFits():
    response.content_type = "application/json; charset=utf-8"
    try:
        body = byteify(json.loads(request.body.read()))
        relFITSFilePath = body['relFITSFilePath']
        iRA = getIntValue(body['iRA'])
        iDEC = getIntValue(body['iDEC'])
        result =  dm.createFits(relFITSFilePath, iRA, iDEC)
    except Exception as e:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        message = "%s ! %s" %  (type(e), "".join(traceback.format_list(traceback.extract_tb(exc_traceback))))
        traceback.print_exc()
        result = {"status": False, "message": message}

    response.content_type = "application/json; charset=utf-8"
    return json.dumps(result)


"""
    Returns all the entries directly located under a given subdirectory.
    The subdirectory must be passed as a full path implicitely
    rooted at FITSFilePrefix.
    i.e. :
    "/" will be interpreted as FITSFilePrefix+"/"
    "/2018" will be interpreted as FITSFilePrefix+"/2018"
    etc...
    The result is a JSON array of dictionaries , on the basis of one dictionary per inode:
    [{'title': filename of the entry, 'key': the FITSFilePrefix rooted path of the entry, 'folder' : true (resp. false) if the inode is (resp. is not) a subdir, 'lazy': true}]
"""
@route( baseUrl+'/getEntries', name='getEntries', method='POST')
@enable_cors
def getEntries() :
    logger.debug("getEntries : entering...")
    response.content_type = "application/json; charset=utf-8"
    try:
        body = byteify(json.loads(request.body.read()))
        logger.debug(request.body)
        relKey = body['relKey']
        result = dm.getEntries(relKey)
    except Exception as e:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        message = "%s ! %s" %  (type(e), "".join(traceback.format_list(traceback.extract_tb(exc_traceback))))
        traceback.print_exc()
        result = {"status": False, "message": message}
    logger.debug("getEntries : exiting")
    return json.dumps(result)

"""
   Returns the rendering capabilities of the server in terms of ITTs, LUTs and video modes ( direct [, reverse ).
   These capabilities are defined in lists of names so that a client knows which names to use e.g. 1) to build
   menus in a GUI  , 2) query the server to apply the ITT and/or LUT and/or video mode of its choice for the
   construction of the images.
"""
@route( baseUrl+'/renderingCapabilities', name='renderingCapabilities', method='GET')
@enable_cors
def renderingCapabilities():
    logger.debug("renderingCapabilities wrapper : entering")
    response.content_type = "application/json; charset=utf-8"
    try:
        result = dm.renderingCapabilities()
    except Exception as e:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        message = "%s ! %s" %  (type(e), "".join(traceback.format_list(traceback.extract_tb(exc_traceback))))
        traceback.print_exc()
        result = {"status": False, "message": message}
    logger.debug("renderingCapabilities wrapper : exiting")
    return json.dumps(result)

"""
  Returns a collection of informations about the DatBlocks present
  in memory at the time of the call.
"""
@route( baseUrl+'/getDataBlockInfos', name='getDataBlockInfos', method='POST')
@enable_cors
def getDataBlockInfos():
    logger.debug("getDataBlockInfos wrapper : entering")
    try:
        result = dm.getDataBlockInfos()
    except Exception as e:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        message = "%s ! %s" %  (type(e), "".join(traceback.format_list(traceback.extract_tb(exc_traceback))))
        traceback.print_exc()
        result = {"status": False, "message": message}
    logger.debug("getDataBlockInfos wrapper : exiting")
    return json.dumps(result)

"""
  Erase the DataBlocks idle for a duration greater than DataBlock.getMaxIdle
  (env var YAFITSS_MAXIDLE)
"""
@route( baseUrl+'/purgeDataBlocks', name='purgeDataBlocks', method='POST')
@enable_cors
def purgeDataBlocks():
    logger.debug("purgeDataBlocks wrapper : entering")
    try:
        result = dm.purgeDataBlocks()
    except Exception as e:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        message = "%s ! %s" %  (type(e), "".join(traceback.format_list(traceback.extract_tb(exc_traceback))))
        traceback.print_exc()
        result = {"status": False, "message": message}
    logger.debug("purgeDataBlocks wrapper : exiting")
    return json.dumps(result)

#
#    End of the class
#
#

#
# HTTP server error handling
#
# @error(500)
def error500(error):
    stack_str=''.join(traceback.format_stack())
    global logger
    logger.debug(f"{stack_str}")
    return f"{error} : {stack_str}"

"""
    start local bottle server
    @port port number
    @debug True if debug enabled
"""
def main(argv):

    global logger
    global dm

    try :
        print (argv)
        opts, args = getopt.getopt(argv[1:], "p:", ["port="])
        print (opts)
    except getopt.GetoptError:
        print ("Bad command")
        sys.exit(2)

    port = 4251
    for opt, arg in opts:
        if opt in ('-p', '--port'):
            port = int(arg)

    logger = logging.getLogger(argv[0])
    logger.setLevel(logging.DEBUG)

    # create console handler and set level to debug
    #ch = logging.StreamHandler()

    #create file handler and set level to debug
    theRootDir = "/home/partemix"
    theLogDir = theRootDir + '/log/'
    theLogFile = theLogDir + os.path.splitext(os.path.basename(argv[0]))[0] + '-'+str(port)+'.log'
    print (theLogFile)
    ch = logging.FileHandler(theLogFile)

    ch.setLevel(logging.DEBUG)

    # create formatter
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

    # add formatter to ch
    ch.setFormatter(formatter)

    # add ch to logger
    logger.addHandler(ch)

    hostname = socket.gethostname()
    logger.debug("%s just starting server on %s:%d" % (argv[0], hostname, port))
    logger.debug("Using astropy version %s" % (astropy.version.version))

    # Obtain a data manager implementation
    dm = dataManager.DataManagerImpl(logger)

    app = default_app()
    run(host=hostname, port=port, debug=True, quiet=False)
    return

if __name__ == '__main__':
    main(sys.argv)