Exemplo n.º 1
0
 def api(self, name, **kwargs):
     """
     Return DAS mapping record about provided API.
     """
     record = self.dasmgr.mapping.api_info(name)
     show = kwargs.get("show", "json")
     page = "<b>DAS mapping record</b>"
     if show == "json":
         jsoncode = {"jsoncode": json2html(record, "")}
         page += self.templatepage("das_json", **jsoncode)
     elif show == "code":
         code = pformat(record, indent=1, width=100)
         page += self.templatepage("das_code", code=code)
     else:
         code = yaml.dump(record, width=100, indent=4, default_flow_style=False)
         page += self.templatepage("das_code", code=code)
     return self.page(page, response_div=False)
Exemplo n.º 2
0
 def api(self, name, **kwargs):
     """
     Return DAS mapping record about provided API.
     """
     record = self.dasmgr.mapping.api_info(name)
     show = kwargs.get('show', 'json')
     page = "<b>DAS mapping record</b>"
     if show == 'json':
         jsoncode = {'jsoncode': json2html(record, "")}
         page += self.templatepage('das_json', **jsoncode)
     elif show == 'code':
         code = pformat(record, indent=1, width=100)
         page += self.templatepage('das_code', code=code)
     else:
         code = yaml.dump(record,
                          width=100,
                          indent=4,
                          default_flow_style=False)
         page += self.templatepage('das_code', code=code)
     return self.page(page, response_div=False)
Exemplo n.º 3
0
    def listview(self, kwargs):
        """
        provide DAS list view
        """
        # force to load the page all the time
        cherrypy.response.headers['Cache-Control'] = 'no-cache'
        cherrypy.response.headers['Pragma'] = 'no-cache'

        time0   = time.time()
        ajaxreq = getarg(kwargs, 'ajax', 0)
        uinput  = getarg(kwargs, 'input', '')
        limit   = getarg(kwargs, 'limit', 10)
        show    = getarg(kwargs, 'show', 'json')
        form    = self.form(uinput=uinput)
        # self.status sends request to Cache Server
        # Cache Server uses das_core to retrieve status
        status  = self.status(input=uinput, ajax=0)
        if  status == 'no data':
            # no data in raw cache, send POST request
            self.send_request('POST', kwargs)
            ctime = (time.time()-time0)
#            page    = self.templatepage('not_ready')
            page  = self.status(input=uinput)
            page  = self.page(form + page, ctime=ctime)
            return page
        elif status == 'fail':
            kwargs['reason'] = 'Unable to get status from data-service'
            return self.error(self.gen_error_msg(kwargs))

        total   = self.nresults(kwargs)
        rows    = self.result(kwargs)
        nrows   = len(rows)
        page    = ""
        ndict   = {'nrows':total, 'limit':limit}
        page    = self.templatepage('das_nrecords', **ndict)
#        for nrecord in range(0, len(rows)):
#            row = rows[nrecord]
#            style = "white"
#            if  nrecord % 2:
#                style = "white"
#            else:
#                style = "gray" 
        style = "white"
        for row in rows:
            id    = row['_id']
            page += '<div class="%s"><hr class="line" />' % style
            gen   = self.convert2ui(row)
            for uikey, value in [k for k, g in groupby(gen)]:
                page += "<b>%s</b>: %s<br />" % (uikey, value)
            pad   = ""
            if  show == 'json':
                jsoncode = {'jsoncode': json2html(row, pad)}
                jsonhtml = self.templatepage('das_json', **jsoncode)
                jsondict = dict(data=jsonhtml, id=id, rec_id=id)
                page += self.templatepage('das_row', **jsondict)
            elif show == 'code':
                code  = pformat(row, indent=1, width=100)
                data  = self.templatepage('das_code', code=code)
                datadict = {'data':data, 'id':id, rec_id:id}
                page += self.templatepage('das_row', **datadict)
            else:
                code  = yaml.dump(row, width=100, indent=4, 
                                default_flow_style=False)
                data  = self.templatepage('das_code', code=code)
                datadict = {'data':data, 'id':id, rec_id:id}
                page += self.templatepage('das_row', **datadict)
            page += '</div>'
        ctime   = (time.time()-time0)
        return self.page(form + page, ctime=ctime)
Exemplo n.º 4
0
    def records(self, *args, **kwargs):
        """
        Retieve all records id's.
        """
        try:
            recordid = None
            format = ''
            if  args:
                recordid = args[0]
                spec = {'_id':recordid}
                fields = None
                query = dict(fields=fields, spec=spec)
                if  len(args) == 2:
                    format = args[1]
            elif  kwargs and '_id' in kwargs:
                spec = {'_id': kwargs['_id']}
                fields = None
                query = dict(fields=fields, spec=spec)
            else: # return all ids
                query = dict(fields=None, spec={})

            nresults = self.nresults(query)
            time0    = time.time()
            url      = self.cachesrv
            idx      = getarg(kwargs, 'idx', 0)
            limit    = getarg(kwargs, 'limit', 10)
            show     = getarg(kwargs, 'show', 'json')
            coll     = getarg(kwargs, 'collection', 'merge')
#            params   = {'query':json.dumps(query), 'idx':idx, 'limit':limit}
#            path     = '/rest/request'
            params   = {'query':json.dumps(query), 'idx':idx, 'limit':limit, 
                        'collection':coll}
            path     = '/rest/records'
            headers  = {"Accept": "application/json"}
            try:
                data = urllib2_request('GET', url+path, params, headers=headers)
                result = json.loads(data)
            except:
                self.daslogger.error(traceback.format_exc())
                result = {'status':'fail', 'reason':traceback.format_exc()}
            res = ""
            if  result['status'] == 'success':
                if  recordid: # we got id
                    for row in result['data']:
                        if  show == 'json':
                            jsoncode = {'jsoncode': json2html(row, "")}
                            res += self.templatepage('das_json', **jsoncode)
                        elif show == 'code':
                            code  = pformat(row, indent=1, width=100)
                            res += self.templatepage('das_code', code=code)
                        else:
                            code = yaml.dump(row, width=100, indent=4, 
                                        default_flow_style=False)
                            res += self.templatepage('das_code', code=code)
                else:
                    for row in result['data']:
                        rid  = row['_id']
                        del row['_id']
                        record = dict(id=rid, daskeys=', '.join(row))
                        res += self.templatepage('das_record', **record)
            else:
                res = result['status']
                if  'reason' in res:
                    return self.error(res['reason'])
                else:
                    msg = 'Uknown error, kwargs=' % kwargs
                    return self.error(msg)
            if  recordid:
                if  format:
                    if  format == 'xml':
                        return self.wrap2dasxml(result['data'])
                    elif  format == 'json':
                        return self.wrap2dasjson(result['data'])
                    else:
                        return self.error('Unsupported data format %s' % format)
                page  = res
            else:
                url   = '/das/records?'
                idict = dict(nrows=nresults, idx=idx, 
                            limit=limit, results=res, url=url)
                page  = self.templatepage('das_pagination', **idict)

            form    = self.form(uinput="")
            ctime   = (time.time()-time0)
            page = self.page(form + page, ctime=ctime)
            return page
        except:
            return self.error(self.gen_error_msg(kwargs))
Exemplo n.º 5
0
 def testJSON2HTML(self):
     """test json2html function"""
     data = {'test': {'foo': 1}}
     expect = json2html(data)
     result = '{\n <code class="key">"test"</code>: {\n    <code class="key">"foo"</code>: <code class="number">1</code>\n   }\n}'
     self.assertEqual(expect, result)
Exemplo n.º 6
0
 def testJSON2HTML(self):
     """test json2html function"""
     data = {'test': {'foo': 1}}
     expect = json2html(data)
     result = '{\n <code class="key">"test"</code>: {\n    <code class="key">"foo"</code>: <code class="number">1</code>\n   }\n}'
     self.assertEqual(expect, result)
Exemplo n.º 7
0
    def listview(self, kwargs):
        """
        provide DAS list view
        """
        # force to load the page all the time
        cherrypy.response.headers['Cache-Control'] = 'no-cache'
        cherrypy.response.headers['Pragma'] = 'no-cache'

        time0 = time.time()
        ajaxreq = getarg(kwargs, 'ajax', 0)
        uinput = getarg(kwargs, 'input', '')
        limit = getarg(kwargs, 'limit', 10)
        show = getarg(kwargs, 'show', 'json')
        form = self.form(uinput=uinput)
        # self.status sends request to Cache Server
        # Cache Server uses das_core to retrieve status
        status = self.status(input=uinput, ajax=0)
        if status == 'no data':
            # no data in raw cache, send POST request
            self.send_request('POST', kwargs)
            ctime = (time.time() - time0)
            #            page    = self.templatepage('not_ready')
            page = self.status(input=uinput)
            page = self.page(form + page, ctime=ctime)
            return page
        elif status == 'fail':
            kwargs['reason'] = 'Unable to get status from data-service'
            return self.error(self.gen_error_msg(kwargs))

        total = self.nresults(kwargs)
        rows = self.result(kwargs)
        nrows = len(rows)
        page = ""
        ndict = {'nrows': total, 'limit': limit}
        page = self.templatepage('das_nrecords', **ndict)
        #        for nrecord in range(0, len(rows)):
        #            row = rows[nrecord]
        #            style = "white"
        #            if  nrecord % 2:
        #                style = "white"
        #            else:
        #                style = "gray"
        style = "white"
        for row in rows:
            id = row['_id']
            page += '<div class="%s"><hr class="line" />' % style
            gen = self.convert2ui(row)
            for uikey, value in [k for k, g in groupby(gen)]:
                page += "<b>%s</b>: %s<br />" % (uikey, value)
            pad = ""
            if show == 'json':
                jsoncode = {'jsoncode': json2html(row, pad)}
                jsonhtml = self.templatepage('das_json', **jsoncode)
                jsondict = dict(data=jsonhtml, id=id, rec_id=id)
                page += self.templatepage('das_row', **jsondict)
            elif show == 'code':
                code = pformat(row, indent=1, width=100)
                data = self.templatepage('das_code', code=code)
                datadict = {'data': data, 'id': id, rec_id: id}
                page += self.templatepage('das_row', **datadict)
            else:
                code = yaml.dump(row,
                                 width=100,
                                 indent=4,
                                 default_flow_style=False)
                data = self.templatepage('das_code', code=code)
                datadict = {'data': data, 'id': id, rec_id: id}
                page += self.templatepage('das_row', **datadict)
            page += '</div>'
        ctime = (time.time() - time0)
        return self.page(form + page, ctime=ctime)
Exemplo n.º 8
0
    def records(self, *args, **kwargs):
        """
        Retieve all records id's.
        """
        try:
            recordid = None
            format = ''
            if args:
                recordid = args[0]
                spec = {'_id': recordid}
                fields = None
                query = dict(fields=fields, spec=spec)
                if len(args) == 2:
                    format = args[1]
            elif kwargs and '_id' in kwargs:
                spec = {'_id': kwargs['_id']}
                fields = None
                query = dict(fields=fields, spec=spec)
            else:  # return all ids
                query = dict(fields=None, spec={})

            nresults = self.nresults(query)
            time0 = time.time()
            url = self.cachesrv
            idx = getarg(kwargs, 'idx', 0)
            limit = getarg(kwargs, 'limit', 10)
            show = getarg(kwargs, 'show', 'json')
            coll = getarg(kwargs, 'collection', 'merge')
            #            params   = {'query':json.dumps(query), 'idx':idx, 'limit':limit}
            #            path     = '/rest/request'
            params = {
                'query': json.dumps(query),
                'idx': idx,
                'limit': limit,
                'collection': coll
            }
            path = '/rest/records'
            headers = {"Accept": "application/json"}
            try:
                data = urllib2_request('GET',
                                       url + path,
                                       params,
                                       headers=headers)
                result = json.loads(data)
            except:
                self.daslogger.error(traceback.format_exc())
                result = {'status': 'fail', 'reason': traceback.format_exc()}
            res = ""
            if result['status'] == 'success':
                if recordid:  # we got id
                    for row in result['data']:
                        if show == 'json':
                            jsoncode = {'jsoncode': json2html(row, "")}
                            res += self.templatepage('das_json', **jsoncode)
                        elif show == 'code':
                            code = pformat(row, indent=1, width=100)
                            res += self.templatepage('das_code', code=code)
                        else:
                            code = yaml.dump(row,
                                             width=100,
                                             indent=4,
                                             default_flow_style=False)
                            res += self.templatepage('das_code', code=code)
                else:
                    for row in result['data']:
                        rid = row['_id']
                        del row['_id']
                        record = dict(id=rid, daskeys=', '.join(row))
                        res += self.templatepage('das_record', **record)
            else:
                res = result['status']
                if 'reason' in res:
                    return self.error(res['reason'])
                else:
                    msg = 'Uknown error, kwargs=' % kwargs
                    return self.error(msg)
            if recordid:
                if format:
                    if format == 'xml':
                        return self.wrap2dasxml(result['data'])
                    elif format == 'json':
                        return self.wrap2dasjson(result['data'])
                    else:
                        return self.error('Unsupported data format %s' %
                                          format)
                page = res
            else:
                url = '/das/records?'
                idict = dict(nrows=nresults,
                             idx=idx,
                             limit=limit,
                             results=res,
                             url=url)
                page = self.templatepage('das_pagination', **idict)

            form = self.form(uinput="")
            ctime = (time.time() - time0)
            page = self.page(form + page, ctime=ctime)
            return page
        except:
            return self.error(self.gen_error_msg(kwargs))
Exemplo n.º 9
0
    def listview(self, kwargs):
        """
        provide DAS list view
        """
        # force to load the page all the time
        cherrypy.response.headers["Cache-Control"] = "no-cache"
        cherrypy.response.headers["Pragma"] = "no-cache"

        time0 = time.time()
        ajaxreq = getarg(kwargs, "ajax", 0)
        uinput = getarg(kwargs, "input", "")
        limit = getarg(kwargs, "limit", 10)
        show = getarg(kwargs, "show", "json")
        form = self.form(uinput=uinput)
        # self.status sends request to Cache Server
        # Cache Server uses das_core to retrieve status
        status = self.status(input=uinput, ajax=0)
        if status == "no data":
            # no data in raw cache, send POST request
            self.send_request("POST", kwargs)
            ctime = time.time() - time0
            #            page    = self.templatepage('not_ready')
            page = self.status(input=uinput)
            page = self.page(form + page, ctime=ctime)
            return page
        elif status == "fail":
            kwargs["reason"] = "Unable to get status from data-service"
            return self.error(self.gen_error_msg(kwargs))

        total = self.nresults(kwargs)
        rows = self.result(kwargs)
        nrows = len(rows)
        page = ""
        ndict = {"nrows": total, "limit": limit}
        page = self.templatepage("das_nrecords", **ndict)
        #        for nrecord in range(0, len(rows)):
        #            row = rows[nrecord]
        #            style = "white"
        #            if  nrecord % 2:
        #                style = "white"
        #            else:
        #                style = "gray"
        style = "white"
        for row in rows:
            id = row["_id"]
            page += '<div class="%s"><hr class="line" />' % style
            gen = self.convert2ui(row)
            for uikey, value in [k for k, g in groupby(gen)]:
                page += "<b>%s</b>: %s<br />" % (uikey, value)
            pad = ""
            if show == "json":
                jsoncode = {"jsoncode": json2html(row, pad)}
                jsonhtml = self.templatepage("das_json", **jsoncode)
                jsondict = dict(data=jsonhtml, id=id, rec_id=id)
                page += self.templatepage("das_row", **jsondict)
            elif show == "code":
                code = pformat(row, indent=1, width=100)
                data = self.templatepage("das_code", code=code)
                datadict = {"data": data, "id": id, rec_id: id}
                page += self.templatepage("das_row", **datadict)
            else:
                code = yaml.dump(row, width=100, indent=4, default_flow_style=False)
                data = self.templatepage("das_code", code=code)
                datadict = {"data": data, "id": id, rec_id: id}
                page += self.templatepage("das_row", **datadict)
            page += "</div>"
        ctime = time.time() - time0
        return self.page(form + page, ctime=ctime)
Exemplo n.º 10
0
    def records(self, *args, **kwargs):
        """
        Retieve all records id's.
        """
        try:
            recordid = None
            format = ""
            if args:
                recordid = args[0]
                spec = {"_id": recordid}
                fields = None
                query = dict(fields=fields, spec=spec)
                if len(args) == 2:
                    format = args[1]
            elif kwargs and kwargs.has_key("_id"):
                spec = {"_id": kwargs["_id"]}
                fields = None
                query = dict(fields=fields, spec=spec)
            else:  # return all ids
                query = dict(fields=None, spec={})

            nresults = self.nresults(query)
            time0 = time.time()
            url = self.cachesrv
            idx = getarg(kwargs, "idx", 0)
            limit = getarg(kwargs, "limit", 10)
            show = getarg(kwargs, "show", "json")
            coll = getarg(kwargs, "collection", "merge")
            #            params   = {'query':json.dumps(query), 'idx':idx, 'limit':limit}
            #            path     = '/rest/request'
            params = {"query": json.dumps(query), "idx": idx, "limit": limit, "collection": coll}
            path = "/rest/records"
            headers = {"Accept": "application/json"}
            try:
                data = urllib2_request("GET", url + path, params, headers=headers)
                result = json.loads(data)
            except:
                self.daslogger.error(traceback.format_exc())
                result = {"status": "fail", "reason": traceback.format_exc()}
            res = ""
            if result["status"] == "success":
                if recordid:  # we got id
                    for row in result["data"]:
                        if show == "json":
                            jsoncode = {"jsoncode": json2html(row, "")}
                            res += self.templatepage("das_json", **jsoncode)
                        elif show == "code":
                            code = pformat(row, indent=1, width=100)
                            res += self.templatepage("das_code", code=code)
                        else:
                            code = yaml.dump(row, width=100, indent=4, default_flow_style=False)
                            res += self.templatepage("das_code", code=code)
                else:
                    for row in result["data"]:
                        rid = row["_id"]
                        del row["_id"]
                        record = dict(id=rid, daskeys=", ".join(row))
                        res += self.templatepage("das_record", **record)
            else:
                res = result["status"]
                if res.has_key("reason"):
                    return self.error(res["reason"])
                else:
                    msg = "Uknown error, kwargs=" % kwargs
                    return self.error(msg)
            if recordid:
                if format:
                    if format == "xml":
                        return self.wrap2dasxml(result["data"])
                    elif format == "json":
                        return self.wrap2dasjson(result["data"])
                    else:
                        return self.error("Unsupported data format %s" % format)
                page = res
            else:
                url = "/das/records?"
                idict = dict(nrows=nresults, idx=idx, limit=limit, results=res, url=url)
                page = self.templatepage("das_pagination", **idict)

            form = self.form(uinput="")
            ctime = time.time() - time0
            page = self.page(form + page, ctime=ctime)
            return page
        except:
            return self.error(self.gen_error_msg(kwargs))