Exemplo n.º 1
0
    def __call__(self,env,response):
        method       = utf8(env.get('REQUEST_METHOD','GET')) 
        get_string   = utf8(env.get('QUERY_STRING',''))
        content_type = utf8(env.get('CONTENT_TYPE','').lower())
        
        GET = {}
        POST = {}

        if content_type == 'multipart/form-data':
        
            ctype, pdict = cgi.parse_header(content_type)        
            if get_string:
                GET = parse_qs(
                    get_string,
                    keep_blank_values=True
                )
            if method == 'POST':
                POST = cgi.parse_multipart(env.copy()['wsgi.input'].read(), pdict)
        
        else:
        
            if get_string:
                GET = parse_qs(
                    get_string,
                    keep_blank_values=True
                )
            if method == 'POST':
                POST = parse_qs(
                    env.copy()['wsgi.input'].read(),
                    keep_blank_values=True
                )
            
        data = dict(GET)
        data.update(dict(POST))
    
        try:
            path        = data.get(self.path,'')
            if not path:
                response('400 Bad Request', self.default_headers )
                return [json_encode({'error':400,'msg':'Bad Request.'})]
            
            params      = data
            path        = map(lambda s:s.capitalize(),path[0].split('.'))
            path.insert(0,'modules')

            try:
                controller = load_module('.'.join(path[:-1]+[path[-2]+'HTTPController']))
                controller = controller(env,response,data,self.default_headers)  
                if not hasattr(controller,path[-1]+'Action'):
                    raise Exception('No such action %s' % '.'.join(path[:-1]+
                        [path[-2]+'Controller',path[-1]+'Action'])
                    )
            except Exception,err:
                logging.error(err)
                response('400 Bad Request', self.default_headers )
                return [json_encode({'error':400,'msg':'Bad Request.'})]

            return getattr(controller,path[-1]+'Action')()
Exemplo n.º 2
0
    def generate_headers(self):
        def encode_robust(obj):
            return repr(obj)
        index = 1
        for log in self.logs:
            code = json_encode(log)
            if len(code) >= HEADER_SIZE_MAX:  # Too large header for firefox, split it
                cut = code[:HEADER_SIZE_MAX]
                rest = code[HEADER_SIZE_MAX:]
                logging.debug(cut)
                yield ('X-Wf-1-1-1-%d' % index, '%d|%s|\\' % (len(code), cut))
                index += 1
                while True:
                    cut = rest[:HEADER_SIZE_MAX]
                    rest = rest[HEADER_SIZE_MAX:]
                    if rest:  # If it's not the end
                        yield ('X-Wf-1-1-1-%d' % index, '|%s|\\' % (cut))
                        index += 1
                    else:  # If it's the end
                        yield ('X-Wf-1-1-1-%d' % index, '|%s|' % (cut))
                        index += 1
                        break

            else:
                yield ('X-Wf-1-1-1-%d' % index, '%d|%s|' % (len(code), code))
                index += 1
        yield ('X-Wf-1-Index', str(index - 1))
Exemplo n.º 3
0
 def __call__(self,env,response):
     try:
         dheaders = dict(self.default_headers)
         nt = Network(200,'REQ',self.servers,self.iopool)
         nt = nt.get_socket()
         try:
             inputdata = env['wsgi.input'].read()
             env['wsgi.input'] = inputdata
             env['wsgi.errors'].close()
             del env['wsgi.errors']
             nt.send({'env':env})
             res = nt.recv()
         except Exception,e:
             logging.debug('500x0 Internal Server Error')
             logging.error(e)
             
         if not isinstance(res,dict): 
             logging.debug('500x1 Internal Server Error')
             response('500 Internal Server Error', self.default_headers)
             return [json_encode({'error':500,'msg':'Internal Server Error'})]  
         if isinstance(res,dict) and res.has_key('e'):  
             logging.debug('500x2 Internal Server Error: %s' % res['e'])
             response('500 Internal Server Error', self.default_headers)
             return [json_encode({'error':res['e'],'msg':'Worker error'})]  
             
         headers = dheaders
         status  = '200 OK' 
         if isinstance(res,dict) and res.has_key('h'): 
             headers  = res['h']
             for i in xrange(len(headers)):
                 headers[i] = tuple(headers[i]) 
         if isinstance(res,dict) and res.has_key('s'): 
             status   = res['s']
         data         = res['d']
         response(status, headers)
         return [utf8(data[0])]
Exemplo n.º 4
0
    def log(self, data):
        """Translate log record into FirePy JSON."""
        pathname = sys._getframe().f_back.f_code.co_filename
        lineno = sys._getframe().f_back.f_lineno
        
        logger = logging
        logging.basicConfig(level=logging.DEBUG)
        formatter = logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s\
%(message)s')

        data = json_encode(data) if not isinstance(data,str) else data
        mess = ''.join([' %s:%s ' % (pathname,lineno),data])
        logger.debug(mess)

        self.logs.append([
            {"Type": 'LOG',
             "File": pathname,
             "Line": lineno},
             data]
        )
Exemplo n.º 5
0
 def IndexAction(self):
     return [json_encode(self.request)]