Ejemplo n.º 1
0
 def main(self,environ,start_response):
     '''dispatch request descibed by WSGI environ
          - satisfies request by corresponding names function in self.app
          - fallback is static file from self.dir
        (WSGI application function)'''
     try:
         if len(environ['PATH_INFO'])>1:
             assert environ['PATH_INFO'].startswith('/') #wsgi always does
             path=environ['PATH_INFO'][1:]
         else:
             path='index.html'
             pass
         return \
             self.dispatchToFunction(path,environ,start_response) or \
             self.dispatchToFile(path,start_response) or \
             self.notFound(path,start_response)
     except Forbidden as e:
         self.log('INFO: '+str(
             inContext(l1(Dispatcher.main.__doc__).format(**vars()))))
         return self.forbidden(start_response)
     except ClientError as e:
         return self.clientError(start_response,e)
     except Exception as e:
         self.logError('ERROR: '+str(
             inContext(l1(Dispatcher.main.__doc__).format(**vars()))))
         return self.serverError(start_response)
     pass
Ejemplo n.º 2
0
def validateSchemaElement(x):
    'verify that %(x)r is a valid json schema element'
    try:
        if x is None: return
        if x in [int,str,float,bool]: return
        if type(x) in [int,str]: return #literal
        if type(x) is dict:
            if len(x) == 1 and list(x.keys())[0] in (int,str):
                validateSchemaElement(list(x.values())[0])
                return
            for name,y in x.items():
                try:
                    assert type(name) is str, type(name)
                    validateSchemaElement(y)
                except:
                    raise inContext('validate dict schema item %(name)r'%vars())
                pass
            return
        if type(x) is list:
            if len(x) == 0:
                raise Exception(
                    'list schema must contain at least one element'%vars())
            for xx in x: validateSchemaElement(xx)
            return
        if type(x) is tuple:
            for i,y in enumerate(x):
                try:
                    validateSchemaElement(y)
                except:
                    raise inContext('validate tuple schema item %(i)r'%vars())
                pass
            return
        if isinstance(x,OneOf):
            for c in x.choices:
                validateSchemaElement(c)
                pass
            return
        if type(x) is bool:
            #fixed literal value True or False
            return
        if isinstance(x,Schema):
            return
        t=type(x)
        if t is object: t=x.__class__
        raise Exception('jsonschema element may not be a %(t)s, it must be a list, a dictionary or int, str, float, bool, tuple or None'%vars())
    except:
        raise inContext(l1(validateSchemaElement.__doc__)%vars())
    pass
Ejemplo n.º 3
0
 def __init__(self, server, staff_password):
     "login in to %(server)s/staff using password %(staff_password)s"
     try:
         self.c = httplib.HTTPConnection(server)
         self.c.set_debuglevel(1)
         self.c.request("GET", "/staff_login.html")
         r = self.c.getresponse()
         page = pq.parse(r.read())
         assert len(page.find(tagName("input")).filter(attrEquals("name", "password"))), (
             r,
             r.getheaders(),
             unicode(page),
         )
         params = urllib.urlencode({"password": staff_password})
         self.c.request("POST", "/staff_login.html", params)
         r = self.c.getresponse()
         assert r.status == 302, (r.status, r.read())
         content = r.read()
         self.session = getSession(r.getheader("Set-Cookie"))
         assert not self.session is None, self.getheaders()
         self.headers = {"Cookie": "kc-session=%s" % self.session}
         assert r.getheader("location") == "http://" + server + "/events.html", repr((r, r.getheaders(), content))
     except:
         raise inContext(l1(Staff.__init__.__doc__) % vars())
     pass
Ejemplo n.º 4
0
def validateCookieName(name):
    '''validate RFC6265 cookie name {name!r}'''
    try:
        return rfc2616.validateToken(name)
    except:
        raise inContext(l1(validateCookieName.__doc__).format(**vars()))
    pass
Ejemplo n.º 5
0
def makeParams(remote_addr,method,headers,params,url,cookies,f):
    'make dictionary of params for calling function %(f)s, getting them from remote_addr, method, headers, query params, post body, url, cookies'''
    try:
        json_params=fromJson(params.get('json_params','{}'))
        param_names=f.__code__.co_varnames[0:f.__code__.co_argcount]
        func_defaults=f.__defaults__ or []
        no_default_params=len(param_names)-len(func_defaults)
        param_defaults=dict([ (param_name,default_value) for param_name,default_value in zip(param_names[no_default_params:],func_defaults)])
        #request.__dict__ does not give us anything useful
        request_attrs={
            'params':params,
            'cookies':cookies,
            'headers':headers,
            'method':method,
            'url':url,
            'remote_addr':remote_addr,
            }
        result=dict([ (_,getParam(_,
                                  json_params,
                                  params,
                                  request_attrs,
                                  param_defaults)) for _ in param_names ])
        return result
    except:
        raise inContext(l1(makeParams.__doc__)%vars())
    pass
Ejemplo n.º 6
0
def validateCookiePath(v):
    '''validate RFC6265 cookie Path value {v!r}'''
    try:
        for i,c in enumerate(v):
            try:
                if c in rfc2616.CTLs:
                    raise Exception('{c!r} is a RFC2616 control character'.format(**vars()))
                if c==';':
                    raise Exception('{c!r} is a semicolon'.format(**vars()))
            except:
                rest=v[i:]
                raise inContext('validate at ...{rest!r}'.format(**vars()))
            pass
        return v
    except:
        raise inContext(l1(validateCookiePath.__doc__).format(**vars()))
    pass
Ejemplo n.º 7
0
def validateSchemaElement(x):
    'verify that %(x)r is a valid json schema element'
    try:
        if x is None: return
        if x in [IntType,StringType,FloatType,BooleanType]: return
        if type(x) in [IntType,StringType,UnicodeType]: return #literal
        if type(x) is DictType:
            if len(x) == 1 and x.keys()[0] in (IntType,StringType):
                validateSchemaElement(x.values()[0])
                return
            for name,y in x.items():
                try:
                    assert type(name) is StringType, type(name)
                    validateSchemaElement(y)
                except:
                    raise inContext('validate dict schema item %(name)r'%vars())
                pass
            return
        if type(x) is ListType:
            if not len(x) == 1:
                i=len(x)
                raise Xn('list schema must contain exactly one element, not %(i)s'%vars())
            validateSchemaElement(x[0])
            return
        if type(x) is TupleType:
            for i,y in enumerate(x):
                try:
                    validateSchemaElement(y)
                except:
                    raise inContext('validate tuple schema item %(i)r'%vars())
                pass
            return
        if isinstance(x,OneOf):
            for c in x.choices:
                validateSchemaElement(c)
                pass
            return
        if isinstance(x,Schema):
            return
        t=type(x)
        if t is ObjectType: t=x.__class__
        raise Xn('jsonschema element may not be a %(t)s, it must be a list, a dictionary or types.IntType, types.StringType, types.UnicodeType, types.FloatType, types.BooleanType, types.TupleType or None'%vars())
    except:
        raise inContext(l1(validateSchemaElement.__doc__)%vars())
    pass
Ejemplo n.º 8
0
def getHTTPHeadersFromWSGIenviron(environ):
    '''get HTTP_ headers from WSGI environ {environ!r} as dictionary'''
    '''like { headerName : str }, e.g.:'''
    try:
        return dict([(name,value) for name,value in environ.items()
                     if name.startswith('HTTP_')])
    except:
        raise inContext(l1(getHTTPHeadersFromWSGIenviron.__doc__).format(**vars()))
    pass
Ejemplo n.º 9
0
def parseDisposition(dispositionValue):
    '''Parse Content-Disposition value %(dispositionValue)s'''
    try:
        assert dispositionValue.strip().startswith('form-data;'), dispositionValue
        v=dispositionValue.split(';')[1:]
        v=[_.strip().split('=',1) for _ in v]
        v=[(_[0],parseQuoted(_[1])) for _ in v]
        return dict(v)
    except:
        raise inContext(parseDisposition.__doc__ % vars())
    pass
Ejemplo n.º 10
0
def parseHeaders(mimePart):
    try:
        h,rest=mimePart.split('\r\n\r\n', 1)
        headers=h.split('\r\n',1)
        headers=[_.split(':',1) for _ in headers]
        headers=[(_[0], _[1].strip()) for _ in headers]
        return dict(headers), rest
    except:
        mps=mimePart[0:256]
        raise inContext('parse headers from mime part %(mps)s...'%vars())
    pass
Ejemplo n.º 11
0
 def verifyUploadedFile(self, uploadedFileId, mime_type, content):
     "verify that %(self)s uploaded_file %(uploadedFileId)s has type %(mime_type)s and content %(content)r"
     scope = Scope(l1(Staff.verifyUploadedFile.__doc__) % vars())
     try:
         r = staff.get("/uploaded_file", {"id": "%(uploadedFileId)s" % vars()})
         assert_equal(r.status, 200)
         assert_equal(r.getheader("Content-Type"), "text/plain")
         assert_equal(r.read(), content)
     except:
         raise inContext(scope.description)
     pass
Ejemplo n.º 12
0
 def postJSON(self, url, params, headers={}):
     'post %(params)r as json encoded "params" to %(url)s'
     "return json-decode response"
     scope = Scope(l1(Staff.postJSON.__doc__) % vars())
     try:
         r = self.post(url, {"params": toJson(params)}, headers)
         assert_equal(r.status, 200)
         return scope.result(fromJson(r.read()))
     except:
         raise inContext(scope.description)
     pass
Ejemplo n.º 13
0
 def post(self, url, params={}, headers={}):
     "send HTTP POST to %(self)r page %(url)r with params %(params)r and headers %(headers)r"
     scope = Scope(l1(Staff.post.__doc__) % vars())
     try:
         assert url.startswith("/"), url
         headers["Cookie"] = "kc-session=%s" % self.session
         self.c.request("POST", url, urllib.urlencode(params), headers)
         return self.c.getresponse()
     except:
         raise inContext(scope.description)
     pass
Ejemplo n.º 14
0
Archivo: pq.py Proyecto: urnest/urnest
def unicodeOfElements(l):
        result=[]
        for i,c in enumerate(l):
            try:
                result.append(unicode(c))
            except:
                t=type(c).__name__
                if t=='instance':
                    t=c.__class__.__name__
                raise inContext('get unicode representation of child %(i)r, %(c)r, which is of type %(t)s'%vars())
            pass
        return result
Ejemplo n.º 15
0
def validateToken(name):
    '''validate RFC2616 token {name!r}'''
    try:
        if not len(name): raise Exception('{name!r} is empty'.format(**vars()))
        for i,c in enumerate(name):
            o=ord(c)
            try:
                if ord(c)<0 or ord(c)>127:
                    raise Exception('{o} not 0..127'.format(**vars()))
                if c in CTLs:
                    raise Exception('{c!r} is a control character'.format(**vars()))
                if c in separators:
                    raise Exception('{c!r} is a separator'.format(**vars()))
            except:
                rest=name[i:]
                raise inContext('validate first char' if i==0 else 'validate char at ...{rest!r}'.format(**vars()))
            pass
        return name
    except:
        raise inContext(l1(validateToken.__doc__).format(**vars()))
    pass
Ejemplo n.º 16
0
 def logout(self, headers={}):
     "logout %(self)s"
     scope = Scope(l1(Staff.logout.__doc__) % vars())
     try:
         headers["Cookie"] = "kc-session=%s" % self.session
         self.c.request("GET", "/logout", "", headers)
         r = self.c.getresponse()
         content = fromJson(r.read())
         assert content["result"] == "OK", content
     except:
         raise inContext(scope.description)
     pass
Ejemplo n.º 17
0
 def __unicode__(self):
     try:
         encodedAttrs=[u'%s="%s"' % (_[0],encodeEntities(_[1])) for 
                       _ in self.attrs.items()]
         encodedAttrs.sort()
         start=u' '.join([self.tagName]+encodedAttrs)
         content=u''.join(unicodeOfElements(self.children))
         end=self.end
         return u'''<%(start)s>%(content)s%(end)s'''%vars()
     except:
         raise inContext('get unicode representation of %(self)r'%vars())
     pass
Ejemplo n.º 18
0
 def verifyFileRefcount(self, uploadedFileId, expectedCount):
     "verify that %(self)s has %(expectedCount)s as uploaded_file %(uploadedFileId)s refcount"
     scope = Scope(l1(Staff.verifyFileRefcount.__doc__) % vars())
     try:
         r = self.get("/uploaded_file_refcount", {"id": uploadedFileId})
         assert r.status == 200, r.status
         content = fromJson(r.read())
         assert "refcount" in content, content
         assert content["refcount"] == expectedCount, (content, expectedCount)
     except:
         raise inContext(scope.description)
     pass
Ejemplo n.º 19
0
def getCookiesFromWSGIenviron(environ):
    '''get cookies from WSGI environ {environ} as dictionary'''
    '''like { cookieName : str or [ str ] }, e.g.:'''
    '''  { "emailAddress" : "*****@*****.**", '''
    '''    "preferredSizes" : [ "L", "XL" ] '''
    try:
        result={}
        e=environ.get('HTTP_COOKIE',None)
        if e: result=dict([_.strip().split('=') for _ in e.split(';')])
        return result
    except:
        raise inContext(l1(getCookiesFromWSGIenviron.__doc__).format(**vars()))
    pass
Ejemplo n.º 20
0
 def dispatchToFunction(self,name,environ,start_response):
     'dispatch {name} to function in {self.app} a name->function dictionary'
     'e.g. app can be a module'
     try:
         fname=name.replace('-','_').replace(' ','_').replace('.','_')
         f=self.app.__dict__.get(fname,None)
         if not f: return None
         if not callable(f):
             raise Forbidden('%(fname)s is not callable ie not a function like "def %(fname)s():"'%vars())
         if not f in public_functions and not f in restricted_functions:
             raise Forbidden('%(fname)s is not annotated with @wal.public (or @public) or @wal.restricted (or @restricted)'%vars())
         result=None
         url=(environ.get('wsgi.url_scheme')+'://'+
              environ.get('HTTP_HOST',
                          environ.get('SERVER_NAME')+':'+
                          environ.get('SERVER_PORT'))+
              environ.get('SCRIPT_NAME','')+
              environ.get('PATH_INFO',''))
         cookies=getCookiesFromWSGIenviron(environ)
         if f in restricted_functions:
             result=restricted_functions[f](url,cookies)
             pass
         if not result:
             params=getVariablesFromWSGIenviron(environ)
             headers=getHTTPHeadersFromWSGIenviron(environ)
             method=environ['REQUEST_METHOD'], #e.g. 'GET', 'POST'
             remote_addr=environ['REMOTE_ADDR']
             result=f(**makeParams(remote_addr,
                                   method,
                                   headers,
                                   params,
                                   url,
                                   cookies,
                                   f))
             pass
         self.log('INFO: {name} used app.{fname}()'.format(**vars()))
         result=result if isinstance(result,Response) \
             else promoteContent(result)
         headers=result.cookieHeaders()
         if result.location:
             headers.append( ('Location',result.location) )
             start_response('301 Moved Permanently',headers)
             return [''.encode('utf-8')]
         headers.extend(result.headers)
         start_response('200 OK',headers)
         return [result.content]
     except:
         raise inContext(l1(Dispatcher.dispatchToFunction.__doc__).format(
             **vars()))
     pass
Ejemplo n.º 21
0
 def cookieHeaders(self):
     '''return headers for {self.cookies}'''
     try:
         result=[] # ('Set-Cookie', xxxx }
         for name,va in self.cookies.items():
             value=va[0]+''.join(['; {an}={av}'.format(**vars())
                                  for an,av in va[1].items()])
             result.append( ('Set-Cookie',
                             '''{name}={value[0]}'''.format(**vars())) )
             pass
         return result
     except:
         raise inContext(
             l1(Response.cookieHeaders.__doc__).format(**vars()))
     pass
Ejemplo n.º 22
0
 def uploadFile(self, fileName, mime_type, content, headers={}):
     "post %(fileName)s of type %(mime_type)s and given content to /uploaded_file, returning resulting id"
     scope = Scope(l1(Staff.__doc__) % vars())
     try:
         r = staff.postFile("/uploaded_file", "filename", fileName, mime_type, content, headers)
         result = fromJson(r.read())
         assert "result" in result, toJson(result).encode("utf8")
         assert "id" in result["result"]
         xxx = result["result"]["id"]
         assert type(xxx) is types.IntType, xxx
         assert xxx != 0, xxx
         return xxx
     except:
         raise inContext(scope.description)
     pass
Ejemplo n.º 23
0
 def postMulipartFormData(self, url, parts, headers={}):
     "post multipart/form-data to %(self)s url %(url)s"
     scope = Scope(l1(Staff.postMulipartFormData.__doc__) % vars())
     try:
         boundary = "------------%08x%08x" % (random.randint(0, 0xFFFFFFFF), random.randint(0, 0xFFFFFFFF))
         while len([_ for _ in parts if boundary in _]):
             boundary = "------------%08x%08x" % (random.randint(0, 0xFFFFFFFF), random.randint(0, 0xFFFFFFFF))
             pass
         body = "\r\n".join(["--" + boundary + "\r\n" + part for part in parts] + ["--" + boundary + "--\r\n"])
         h = dict(headers.items())
         h["Content-Type"] = "multipart/form-data; boundary=%(boundary)s" % vars()
         h["Cookie"] = "kc-session=%s" % self.session
         self.c.request("POST", url, body, h)
         return self.c.getresponse()
     except:
         raise inContext(scope.description)
     pass
Ejemplo n.º 24
0
def deletePreFairHelper(stall_name,helper_name,email):
    'delete pre-fair helper %(helper_name)s of email %(email)s from stall %(stall_name)s'
    scope=Scope(l1(deletePreFairHelper.__doc__)%vars())
    try:
        entry_query = StallPreFairHelper.query(
            ancestor=stall_key(stall_name))
        entries = entry_query.fetch(1000)
        entries=[_ for _ in entries \
                     if _.name==helper_name and _.email==email]
        if len(entries)==0:
            return scope.result('no such helper')
        entry=entries[0]
        entry.key.delete()
        return scope.result('entry deleted'%vars())
    except:
        raise inContext(scope.description)
    pass
Ejemplo n.º 25
0
def deleteHelper(stall_name,hour,helper_number):
    'delete helper with index %(helper_number)s from hour %(hour)s from stall %(stall_name)s'
    scope=Scope(l1(deleteHelper.__doc__)%vars())
    try:
        entry_query = OneHourOfHelp.query(OneHourOfHelp.hour == hour, ancestor=stall_key(stall_name))
        entries = entry_query.fetch(1)
        if len(entries)==0:
            return scope.result('no such hour of help')
        entry=entries[0]
        del entry.names[helper_number]
        del entry.emails[helper_number]
        del entry.phones[helper_number]
        entry.put()
        return scope.result('entry now %(entry)s'%vars())
    except:
        raise inContext(scope.description)
    pass
Ejemplo n.º 26
0
 def __radd__(self,lhs):
     'add Response {self} to {lhs}'
     try:
         assert isinstance(lhs,Response)
         rhs=self
         assert lhs.content=='' or rhs.content=='', 'content specified more than once'
         result=Response()
         result.content=rhs.content or lhs.content
         result.contentType=rhs.contentType or lhs.contentType
         result.contentEncoding=rhs.contentEncoding or lhs.contentEncoding
         result.cookies=lhs.cookies.copy()
         result.cookies.update(rhs.cookies)
         result.headers=lhs.headers+rhs.headers
         result.location=rhs.location or lhs.location
         return result
     except:
         raise inContext(l1(Response.__radd__.__doc__).format(**vars()))
     pass
Ejemplo n.º 27
0
 def postFile(self, url, fieldName, fileName, mime_type, data, headers={}):
     "post file %(fileName)s of type %(mime_type)s as field %(fieldName)s to %(self)s url %(url)s"
     scope = Scope(l1(Staff.postFile.__doc__) % vars())
     try:
         lines = [
             'Content-Disposition: form-data; name="%(fieldName)s"; filename="%(fileName)s"'
             % {
                 "fieldName": fieldName.replace(r'"', r"\"").encode("ascii"),
                 "fileName": fileName.replace(r'"', r"\"").encode("ascii"),
             },
             "Content-Type: %(mime_type)s" % vars(),
             "",
             data,
         ]
         part = "\r\n".join(_ for _ in lines)
         return self.postMulipartFormData(url, [part], headers)
     except:
         raise inContext(scope.description)
     pass
Ejemplo n.º 28
0
def promoteContent(content):
    '''promote content object of type {contentType} to a valid Response'''
    contentType=type(content)
    try:
        if isinstance(content,pq.Selection):
            return Response(content.utf8(),
                            'text/html; charset=UTF-8')
        if isinstance(content,dict) and (
            'result' in content or
            'error' in content):
            return Response(toJson(content).encode('utf-8'),
                            'text/json; charset=UTF-8')
        if content is None or \
           isinstance(content,dict) or isinstance(content,list) or \
           isinstance(content,int) or isinstance(content,float):
            return Response(toJson({'result':content}).encode('utf-8'),
                            'text/json; charset=UTF-8')
        raise Exception('do not know what HTTP HTTP CONTENT-TYPE to use for a {contentType} object - return an explicit wal.Response to set CONTENT-TYPE'.format(**vars()))
    except:
        raise inContext(l1(promoteContent.__doc__).format(**vars()))
    pass
Ejemplo n.º 29
0
def validateCookieValue(v):
    '''validate RFC6265 cookie-value {v!r}'''
    try:
        if v.startswith('"') and not v.endswith('"'):
            raise Exception('{v!r} startswith double quote but does not end with double quote'.format(**vars()))
        x=v[1:-1] if v.startswith('"') else v
        for i,c in enumerate(x):
            o=ord(c)
            if o<0x21 or \
               (o>0x21 and o<0x23) or \
               (o>0x2b and o<0x2d) or \
               (o>0x3a and o<0x3c) or \
               (o>0x4b and o<0x5d) or \
               (o>0x7e):
                rest=result[i:]
                raise Exception('invalid character at {rest!r}'.format(**vars()))
            pass
        return v
    except:
        raise inContext(l1(validateCookieValue.__doc__).format(**vars()))
    pass
Ejemplo n.º 30
0
def getParam(param_name,
             json_params,
             request_params,
             request_attrs,
             param_defaults):
    try:
        try:
            if param_name in json_params:
                return json_params.get(param_name)
            if param_name in request_params:
                return request_params.get(param_name)
            if param_name in request_attrs:
                return request_attrs.get(param_name)
            return param_defaults[param_name]
        except KeyError as e:
            raise Exception('unknown parameter')
        pass
    except:
        json_param_names=json_params.keys()
        request_param_names=request_params.keys()
        request_attr_names=request_attrs.keys()
        param_default_names=param_defaults.keys()
        raise inContext('get value of %(param_name)s from params supplied as json-encoded "json_params" HTTP param (%(json_param_names)s), HTTP params (%(request_param_names)s), webapp2 request attributes (%(request_attr_names)s) or function paramter defaults (%(param_default_names)s)'%vars())
    pass