Python reporter.Reporter类代码示例

def get_report(record_id):  
    keyToken='token'
    if keyToken in request.params.keys():
        token=request.params.get(keyToken)
    else:
        return wrapResults({"error":{'code':0,'msg':"No token provided!"}})
    accessible=auth.getAccessibleProducts(token)
    if 'error' in accessible:
        return wrapResults(accessible)
    if len(accessible['products'])==0:
        return wrapResults({'error':{'code':0,'msg':'No accessible products.'}})

    reporter=Reporter() 
    data=reporter.get_report(record_id)
    #print data
    sysInfo=data.pop('sys_info')
    si={}
    for key in sysInfo:
        rKey=key.replace(':','.')
        si[rKey]=sysInfo[key]
    if not 'android.os.Build.PRODUCT' in si:
        return wrapResults({'error':{'code':0,'msg':'Permission denial.'}})
    if not si['android.os.Build.PRODUCT'] in accessible['products']:
        return wrapResults({'error':{'code':0,'msg':'Permission denial.'}})
    else:
        data['sys_info']=si
        return wrapResults(data)

def latest():
    '''
    Get the latest n records.
    Paramenters:
    count=n(max=100,default=20)
    
    Return:
    Headers:
    Content-Type:application/json    
    Body:
    A json array and every element in the array is a json document.
    array:[{},{}]
    document:{"_id":id,"receive_time":time,"json_str":original}     
    
    '''
    keyToken='token'
    if keyToken in request.params.keys():
        token=request.params.get(keyToken)
    else:
        return wrapResults({"error":"No token provided!"})
    accessible=auth.getAccessibleProducts(token)
    if 'error' in accessible:
        return wrapResults(accessible)
    if len(accessible['products'])==0:
        return wrapResults({'error':'No accessible products.'})    

    limit=request.params.get('limit')
    reporter=Reporter()
    data=reporter.latest(limit)
    result=[]
    for record in data:
        if record['product'] in accessible['products']:
            result.append(record)
    return wrapResults(result)

def main(args):
    if args.v:
        print args

    genes = read_genes(args)
    if args.v:
        print "%d genes" % len(genes)

    reporter = Reporter(Host(), genes)

    try:
        out = open(args.out_fn, "w")
    except IOError:
        out = sys.stdout
    except TypeError:
        out = sys.stdout

    out.write(reporter.report())
    for k in sorted(reporter.stats.keys()):
        out.write("%-20s: %s\n" % (k, reporter.stats[k]))

    if out != sys.stdout:
        out.close()

    return 0

def download():
    keyToken='token'
    if keyToken in request.params.keys():
        token=request.params.get(keyToken)
    else:
        return wrapResults({"error":"No token provided!"})
    accessible=auth.getAccessibleProducts(token)
    if 'error' in accessible:
        return wrapResults(accessible)
    if len(accessible['products'])==0:
        return wrapResults({'error':'No accessible products.'})

    paging=getPagingParameters()    
    conds = getFilterConditions()
    conds.pop('token')
    if 'android.os.Build.PRODUCT' in conds:
        if not (conds['android.os.Build.PRODUCT'] in accessible['products']):
            return wrapResults({'error':'You have no rights to view the data of product:%s'%conds['android.os.Build.PRODUCT']})
    result=viewer.errors(accessible['products'],paging,conds)
    if result is None:
        return wrapResults({'error':{'code':0,'msg':'Result is empty! Change the conditions and try again!'}})
    else:
        reporter=Reporter()
        ids=result['data']
        records=reporter.get_batch_report(ids)
        result['data']=records
        print records[0]
        #return wrapResults(result)
        f=viewer.error_list_excel(records)
        response.set_header('Content-Type','application/vnd.ms-excel')
        response.set_header("Content-Disposition", "attachment;filename=errorlist.xls");
        return f

def error():
    '''
    About paging:
    request:query/error?conditions&page=1&records=25&paging_token=xxx-xxx
    response: {"results":{"paging":{"totalrecords":100,"totalpages":10,"records":10,"page":1,"paging_token":"xxx-xxx"},"data":[{},{}]}}
    '''
    keyToken='token'
    if keyToken in request.params.keys():
        token=request.params.get(keyToken)
    else:
        return wrapResults({"error":"No token provided!"})
    accessible=auth.getAccessibleProducts(token)
    if 'error' in accessible:
        return wrapResults(accessible)
    if len(accessible['products'])==0:
        return wrapResults({'error':'No accessible products.'})

    paging=getPagingParameters()    
    conds = getFilterConditions()
    conds.pop('token')
    if 'android.os.Build.PRODUCT' in conds:
        if not (conds['android.os.Build.PRODUCT'] in accessible['products']):
            return wrapResults({'error':'You have no rights to view the data of product:%s'%conds['android.os.Build.PRODUCT']})
    result=viewer.errors(accessible['products'],paging,conds)
    if result is None:
        return wrapResults({'error':{'code':0,'msg':'Result is empty! Change the conditions and try again!'}})
    else:
        reporter=Reporter()
        ids=result['data']
        records=reporter.get_batch_report(ids)
        result['data']=records
        return wrapResults(result)

	def __init__(self, identity, src, sink, amount, start):
		Reporter.__init__(self, identity)
		self.source = src
		self.dest = sink
		self.size = float(amount) * 8000.0 			# amount in MByte -> 1000*8 KBits
		self.start_time = float(start) * 1000.0		# 1000ms in a second
		self.am_i_done = 0

def getUserData(user,linkTemplate,ids):
    '''
    Paramenters:
    user: phonenumber or imsi
    linkTemplate: "errors?phoneNumber=%s&date=%s" or "errors?imsi=%s&date=%s"
    '''
    idList=[]
    for id in ids:
        idList.append(int(id))        
    spec={"_id":{"$in":idList}}
    fields=['category','receive_time']
    reporter=Reporter()
    records=reporter.getDatas(spec,fields)

    data={}
    for record in records:
        recTime=record['receive_time']
        category=record['category']
        key=recTime.strftime('%Y%m%d')
        if not key in data:
            data[key]={"live": 0, "link": linkTemplate%(user,key), "error": 0}            
        if category=='ERROR':
            data[key]['error']+=1
        else:
            data[key]['live']+=1
    return data

def generate_report(bundle, results, options, status, html_filename,
                    json_filename):
    bundle_yaml = get_bundle_yaml(status)
    reporter = Reporter(bundle=bundle, results=results, options=options,
                        bundle_yaml=bundle_yaml)
    reporter.generate(html_filename=html_filename,
                      json_filename=json_filename)

 def test_generate_with_svg(self):
     tempdir = mkdtemp()
     json_file = os.path.join(tempdir, 'file.json')
     html_file = os.path.join(tempdir, 'file.html')
     svg_file = os.path.join(tempdir, 'file.svg')
     results = self.make_results()
     fake_request = FakeRequest()
     args = self.make_args()
     reporter = Reporter(bundle='git', results=results, options=args,
                         bundle_yaml='bundle content')
     with patch('reporter.requests.post',
                autospec=True, return_value=fake_request) as mock_r:
         reporter.generate(html_filename=html_file, json_filename=json_file)
     mock_r.assert_called_once_with('http://svg.juju.solutions',
                                    'bundle content')
     with open(json_file) as fp:
         json_content = json.loads(fp.read())
     with open(html_file) as fp:
         html_content = fp.read()
     with open(svg_file) as fp:
         svg_content = fp.read()
     self.assertIn('charm-proof', html_content)
     self.assertEqual(json_content["bundle"]["name"], 'git')
     self.assertEqual(json_content["test_id"], '1234')
     self.assertEqual(svg_content, 'svg content')
     rmtree(tempdir)

 def __init__(self, registry, refresh_interval, filename=None):
     Reporter.__init__(self, registry, refresh_interval)
     self._filename = filename
     if filename:
         self._fh = open(filename, 'w')
     else:
         self._fh = sys.stdout
     return

 def test_get_test_outcome(self):
     r = Reporter(None, None, None)
     results = [r.pass_str, r.pass_str]
     self.assertEqual(r.get_test_outcome(results), r.all_passed_str)
     results = [r.pass_str, r.fail_str]
     self.assertEqual(r.get_test_outcome(results), r.some_failed_str)
     results = [r.fail_str, r.fail_str]
     self.assertEqual(r.get_test_outcome(results), r.all_failed_str)

def main(cmd, files, output, redis_address):
    logger = Logger(stream=output == 'stream')
    reporter = Reporter(**redis_address)

    perf_report = reporter.get_report(files)
    schedule = scheduler.make(perf_report, spawner.parallelism())
    perf_report = spawner.execute(cmd, schedule, logger)

    reporter.submit(perf_report)

def get_log(record_id): 
    ##print 'get_log()'    
    reporter=Reporter()    
    log=reporter.get_log(record_id)
    if log==None:
        abort(404,"Can not find the log!")
    else:
        response.set_header('Content-Type','application/x-download')
        response.set_header('Content-Disposition','attachment; filename=log_'+record_id+'.zip',True)
        return log

 def __init__(self, input_dir, output_dir=None, tmp_dir=None):
     self.input_dir = input_dir
     self.output_dir = output_dir
     self.tmp_dir = tmp_dir
     self.storer = Storer()
     self.name = self.__class__.__name__
     self.repok = Reporter(prefix="[%s - INFO] " % self.name)
     self.repok.new_article()
     self.reper = Reporter(prefix="[%s - ERROR] " % self.name)
     self.reper.new_article()

 def test_generate_html(self):
     r = Reporter(None, None, None)
     with NamedTemporaryFile() as html_file:
         html_output = r.generate_html(
             json_content=self.make_json(), output_file=html_file.name,
             past_results=[])
         content = html_file.read()
     self.assertRegexpMatches(html_output, 'AWS')
     self.assertRegexpMatches(html_output, 'Joyent')
     self.assertRegexpMatches(content, 'AWS')
     self.assertRegexpMatches(content, 'Joyent')