def dispatch(self, env, start_resp):
     "Dispatch both on resources and sub applications"
     reqmeth = env['REQUEST_METHOD']
     script_name = env.get('SCRIPT_NAME', '')
     path_info = env.get('PATH_INFO', '')
     fullpath = script_name + path_info
     for (path, meth), obj in self._registry.iteritems():
         mo = re.match(path, path_info)
         print 'checking %s with %s, %s' % (path_info, path, mo)
         if mo:
             if not isinstance(obj, self.Binding): # assume WSGI app
                 shift_path_info(env) # subdispatch
                 res = obj
             else: # true resource
                 resource = obj.resource
                 if resource is None:
                     res = Response('Unbound Resource', '500 ERR')
                 elif meth not in ('ALL', reqmeth):
                     res = Response('Method Not Allowed', '405 ERR')
                 else: # call the resource
                     res = safecall(
                         self.call_hook, resource, self.Request(env), 
                         mo.groups(), obj.content_type, path)
             break
     else: # no match, no break
         res = Response('Unknown resource %r' % fullpath, '404 Not Found')
     return res(env, start_resp)

def remote_webapp (environ, start_response):
    routes = {
        'buttons': view_buttons,
        'inputs': view_inputs,
        'press': lambda: press(shift_path_info (environ)),
        'status': projector_status,
        'input': lambda: set_input(shift_path_info (environ)),
        'on': on,
        'off': off,
        '': index
    }

    result = None
    base_path = shift_path_info (environ)
    if base_path not in routes:
        status = '404 Not Found'
        headers = [('Content-type', 'text/html')]
        result = str(WebException (status))
    else:
        try:
            handler = routes[base_path]
            result = handler()
            status = '200 OK'  # HTTP Status
            if type(result) != str and type(result) != unicode:
                headers = [('Content-type', 'text/html')] 
            else:
                headers = [('Content-type', 'application/json')]
        except WebException, ex:
            status = ex.code
            headers = [('Content-type', 'text/html')] 
            result = str(ex)
        except:

 def __call__(self, environ, start_response):
     if self.prefix and not environ['PATH_INFO'].startswith(self.prefix):
         return self._error(start_response, 400, "bad request")
     shift_path_info(environ)
     qs = parse_qs(environ.get('QUERY_STRING'), strict_parsing=True)
     if 'auth_token' not in qs:
         if self.need_auth(environ):
             return self._error(start_response, 401, "unauthorized",
                                "Missing Authentication Token.")
     else:
         token = qs['auth_token'][0]
         try:
             self.verify_token(environ, token)
         except Unauthorized:
             return self._error(
                 start_response, 401, "unauthorized",
                 "Incorrect password or login.")
         # remove auth token from query string.
         del qs['auth_token']
         qs_str = ''
         if qs:
             qs_str = reduce(lambda x, y: '&'.join([x, y]),
                             map(lambda (x, y): '='.join([x, str(y)]),
                                 qs.iteritems()))
         environ['QUERY_STRING'] = qs_str
     return self.app(environ, start_response)

def static(environ, start_response):
    # shift PATH_INFO /static/foo ----> /foo
    # then skip first '/'
    # and merge with static_root
    shift_path_info(environ)
    filename = os.path.abspath(os.path.join(static_root,
                                            environ['PATH_INFO'][1:]))
    return sendfile(fname, start_response)

 def __call__(self, environ, start_response):
     """Dispatch to the method named by the next bit of PATH_INFO."""
     name = shift_path_info(dict(SCRIPT_NAME=environ["SCRIPT_NAME"], PATH_INFO=environ["PATH_INFO"]))
     callable = getattr(self, name or "index", None)
     if callable is not None and self._is_exposed(callable):
         shift_path_info(environ)
         return callable(environ, start_response)
     else:
         return self._not_found(environ, start_response)

def select_app(environ,start_response):
	active_app=apps[None]
	path=environ['PATH_INFO']
	for app in apps:
		if app is None: continue
		if path=='/'+app or path.startswith('/'+app+'/'):
			shift_path_info(environ)
			active_app=apps[app]
			break
	return active_app(environ,start_response)

def simple_dispatch(environ, start_response):
    status = '200 OK' # HTTP Status
    headers = [('Content-type', 'text/html')] # HTTP Headers
    start_response(status, headers)
    environ["parsed_params"] = urlparse.parse_qs(environ["QUERY_STRING"],keep_blank_values=True)
    # a wsgi app is supposed to return an iterable;
    # yielding lets you stream, rather than generate everything at once.
#    yield repr(environ)
    dbname = shift_path_info(environ)
    myname = environ["SCRIPT_NAME"]
    print >> environ['wsgi.errors'], dbname
    if not dbname: return
    else:
        dbfile = "/var/lib/philologic/databases/" + dbname + "/toms.db"
    toms = SqlToms(dbfile,7)
    print >> environ['wsgi.errors'],"opened toms"
    obj = []
    count = 0

    while True:
        p = shift_path_info(environ)
        if p:
            obj.append(p)
        else:
            break
    yield "looking up %s" % str(obj)
    filename = ""
    start = 0
    end = 0
    length = 0
    for r in range(1,len(obj) + 1):
        parent = obj[:r]
        yield str(parent)
        if parent in toms:
            yield "retreiving %s" % repr(parent)
            o = toms[parent]
            filename = o["filename"] or filename
            start = o["start"] or start
            end = o["end"] or end
    yield repr((filename,length,start,end))
    file = "/var/lib/philologic/databases/%s/TEXT/%s" % (dbname,filename)
    fh = open(file)
    fh.seek(start)
    chunk = fh.read(end - start)
    if "word_offset" in environ["parsed_params"]:
        word_offset =  int(environ["parsed_params"]["word_offset"][0])
        if word_offset >= start and word_offset <= end:
            breakpoint = word_offset - start
            left = chunk[:breakpoint]
            rest = chunk[breakpoint:]
            word,right = re.split("[\s.;:,<>?!]",rest,1)    
            yield f.format(left + "<span rend='preserve' class='hilite'>" + word + "</span> " + right)
            return
    yield f.format(chunk)

 def handle_request(self, env, start):
     parts = env["PATH_INFO"].split("/")[1:]
     locale = None
     if len(parts):
         locale = to_gettext_locale(parts[0])
     if locale:
         env = dict(env)
         shift_path_info(env)
         self.maybe_apply_translation(env, locale)
         if "translation" in env or locale == NULL_LOCALE:
             return self.file_server.handle_request(env, start)

 def app(environ, start_response):
     parts = environ['PATH_INFO'].split('/')[1:]
     if len(parts) >= 2 and parts[0] == multiplex_dir:
         app = multiplex_apps.get(parts[1])
         if len(parts) > 2 and app:
             shift_path_info(environ)
             shift_path_info(environ)
             return app(environ, start_response)
         else:
             start_response('404 Not Found',
                            [('Content-Type', 'text/plain')])
             return ['Not Found']
     return default_app(environ, start_response)

 def __call__(self, environ, start_response):
     """Dispatch to the method named by the next bit of PATH_INFO."""
     # Predict the path shift to get the callable name.
     name = shift_path_info(dict(SCRIPT_NAME=environ['SCRIPT_NAME'],
                                 PATH_INFO=environ['PATH_INFO']))
     # If there is such a callable and it is exposed...
     callable = getattr(self, name or 'index', None)
     if callable is not None and self._is_exposed(callable):
         # ... shift the path and call the callable.
         shift_path_info(environ)
         return callable(environ, start_response)
     else:
         # ... or call self._not_found (
         return self._not_found(environ, start_response)

def application(env, start):
    env['htmlpad.etherpad'] = 'etherpad.mozilla.org:9000'
    ## ianb: cwd sensitive:
    static_files_dir = os.path.join('htmlpad.org', 'static-files')

    # Clearing the template cache on each request allows developers
    # to iterate quickly.
    htmlpad.template_cache = {}

    if env['PATH_INFO'].startswith('/static-files/'):
        shift_path_info(env)
        return static_file(env, start, static_files_dir)
    else:
        return htmlpad.application(env, start)

    def __init__(self, environ):
        ctrlr_class = shift_path_info(environ)
        ctrlr_action = shift_path_info(environ)
        
        if ctrlr_class == '' or ctrlr_class == None:
            ctrlr_class = 'home'
        
        if ctrlr_action == '' or ctrlr_action == None:
            ctrlr_action = 'index'

        # Class Members
        self.ctrlr_file = 'controller.' + ctrlr_class
        self.ctrlr_class = ctrlr_class
        self.ctrlr_action = ctrlr_action

def strip_app(environ,start_response):
	if environ['PATH_INFO']=='/':
		environ['PATH_INFO']='/index.html'
	if environ['PATH_INFO'].startswith('/api'):
		shift_path_info(environ)
	else:
		try:
			filename=os.path.join(os.getcwd(),'client','html',environ['PATH_INFO'][1:])
			f=open(filename,'rb')
		except fnfError:
			start_response("404 NOT FOUND",[])
			return []
		start_response("200 OK",[])
		return f
	return matomat_wsgi.application(environ,start_response)

    def handle(self, request):
        '''Handle a request, parse and validate arguments and dispatch the request'''

        entity = pop_path_info(request.environ)
        if not entity:
            return self.handle_index()

        if entity not in [ 'release', 'release-group' ]:
            return Response (
                status=400, response=
                "Only release and release-group entities are currently supported")

        req_mbid = shift_path_info(request.environ)
        if not req_mbid:
            return Response (status=400, response="no MBID specified.")
        if not re.match('[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$', req_mbid):
            return Response (status=400, response="invalid MBID specified.")

        mbid = self.resolve_mbid (entity, req_mbid)
        filename = pop_path_info(request.environ)

        if entity == 'release-group':
            return self.handle_release_group (request, mbid, filename)
        else:
            return self.handle_release (request, mbid, filename)

def bookings_room_page(environ):
    """Provide a list of bookings by room, showing user and date/time
    """
    room_id = int(shift_path_info(environ))
    room = get_room(room_id)
    html = "<table>"
    html += "<tr><td>User</td><td>Date</td><td>Times</td></tr>"
    for booking in get_bookings_for_room(room_id):
        html += "<tr><td>{user_name}</td><td>{booked_on}</td><td>{booked_from} - {booked_to}</td></tr>".format(
            user_name=booking['user_name'],
            booked_on=booking['booked_on'],
            booked_from=booking['booked_from'] or "",
            booked_to=booking['booked_to'] or ""
        )
    html += "</table>"
    html += "<hr/>"
    html += '<form method="POST" action="/add-booking">'
    html += '<input type="hidden" name="room_id" value="{room_id}"/>'.format(room_id=room_id)
    html += '<label for="user_id">User:</label>&nbsp;<select name="user_id">'
    for user in get_users():
        html += '<option value="{id}">{name}</option>'.format(**user)
    html += '</select>'
    html += '&nbsp;|&nbsp;'
    html += '<label for="booked_on">On</label>&nbsp;<input type="text" name="booked_on" value="{today}"/>'.format(today=datetime.date.today())
    html += '&nbsp;<label for="booked_from">between</label>&nbsp;<input type="text" name="booked_from" />'
    html += '&nbsp;<label for="booked_to">and</label>&nbsp;<input type="text" name="booked_to" />'
    html += '<input type="submit" name="submit" value="Add Booking"/></form>'
    return page("Bookings for %s" % room['name'], html)

def __call__(environ, start_response):
    """Handle a HTTP request."""
    from wsgiref.util import application_uri, shift_path_info
    from urlparse import urljoin

    try:
        import swat
    except ImportError as e:
        print("NO SWAT: %r" % e)
        have_swat = False
    else:
        have_swat = True

    orig_path = environ['PATH_INFO']
    name = shift_path_info(environ)

    if name == "":
        if have_swat:
            start_response('301 Redirect',
                [('Location', urljoin(application_uri(environ), 'swat')),])
            return []
        else:
            return render_placeholder(environ, start_response)
    elif have_swat and name == "swat":
        return swat.__call__(environ, start_response)
    else:
        status = '404 Not found'
        response_headers = [('Content-type', 'text/html')]
        start_response(status, response_headers)
        return ["The path %s (%s) was not found" % (orig_path, name)]

 def __call__(self, env, resp):
     name = shift_path_info(env)
     app = self.pages.get(name)
     if not app:
         resp('404 ERR', [('Content-type', 'text/plain')])
         return ['Page %s not found' % name]
     return app(env, resp)

def app(environ, start_response):
    path = shift_path_info(environ)
    print(path)
    if path == 'api':
        return mxreverse(environ, start_response)
    start_response('301 Moved', [('Location', '/page/index.html')])
    return [b'']

def messages(env, conn):
    channel = shift_path_info(env)
    if channel != None and channel != "":
        # TODO: escape parameters
        messages = []
        try:
            table = getattr(conn.db, channel);
        except:
            return (404, "Invalid channel", JSON)

        request = parse_qs(env["QUERY_STRING"])
        limit = 50
        query = {}
        if "limit" in request:
            limit = request["limit"][0]
        if "types" in request:
            types = request["types"][0]
            query["$or"] = []
            for type_ in types.split(","):
                try:
                    value = int(type_)
                except:
                    continue
                query["$or"].append({"type": value})

        for doc in table.find(query, limit=limit, sort=[("$natural", pymongo.DESCENDING)]):
            messages.append(doc)

        return (200, json.dumps(messages, default=bson.json_util.default), JSON)


    else:
        return (404, "Channel not specified", JSON)

    def post_resource():
        ctype = environ.get('CONTENT_TYPE', 'application/unknown')
        clen = int(environ.get('CONTENT_LENGTH', None))
        if not clen:
            start_response("411 Length Required", [('Content-Type','text/plain')])
            return ["Length Required"]
        key = shift_path_info(environ)
        now = datetime.now().isoformat()
        md = {
            CREATED: now,
            UPDATED: now,
            CONTENT_LENGTH: clen,
            CONTENT_TYPE: ctype,
        }
        #md = self.standard_index
        content = environ['wsgi.input'].read(clen)
        id = drv.create_resource(content, metadata=md)
        msg = 'Adding %i' % id
        new_uri = str(id)

        headers = [('Content-Type', 'text/plain')]
        headers.append(('Location', new_uri))
        headers.append(('Content-Location', new_uri))

        #environ['akara.etag'] = compute_etag(content)
        headers.append(('Content-Length', str(len(msg))))
        start_response("201 Created", headers)
        
        return msg