def log_hit(self):
        # Make sure we get plain strings, not unicode
        #self.request.charset = None 
        cur = self.request.str_GET.get('cur', None)
        ref = self.request.str_GET.get('ref', None)
        title = self.request.str_GET.get('title', None)

        if not cur:
            cur = self.request.headers.get('referer', None)
        
        if cur is not None:
            cur = get_unicode(unquote_plus(cur))
        if ref is not None:
            ref = get_unicode(unquote_plus(ref))
        if title is not None:
            title = get_unicode(unquote_plus(title)).strip()

        response = Response()
        response.headers['Content-Type'] = "image/gif"
        response.headers['Expires'] = "Sat, 26 Jul 1997 05:00:00 GMT"
        response.headers['Cache-Control'] = "no-cache, must-revalidate"
        response.body = self._image

        if not cur:
            return response

        visitor_ip = self.request.headers.get('X-Forwarded-For', None)
        if visitor_ip is None:
            visitor_ip = self.request.remote_addr

        hit = Hit(self._conf, cur, referrer=ref, title=title,
            visitor_ip=visitor_ip)
        if hit.is_whitelisted() and not hit.is_blacklisted():
            self._storage.add_hit(hit)
        return response

    def dispatch_wsgi(self, environ, start_response):
        """
        Dispatches a WSGI request.

        :param environ: WSGI request environment.
        :param start_response: WSGI response callback
        :returns: A valid WSGI response content.
        """
        req = Request(environ)
        req.response = Response()

        try:
            resp = self.dispatch_request(req)
        except HTTPException as e:
            resp = e

        if inspect.isgenerator(resp):
            resp = Response(app_iter=resp)
        elif resp is None:
            resp = req.response
        if isinstance(resp, text_type):
            resp = bytes_(resp, req.charset)
        if isinstance(resp, bytes):
            body = resp
            resp = req.response
            resp.write(body)
        if resp is not req.response:
            resp = req.response.merge_cookies(resp)
        return resp(environ, start_response)

def login(request):
    """
    handles session login
    """
    try:
        params = _get_params_by_ct(request)
        username = params['username']
        password = params['password']
    except: 
        return HttpResponse(status=400)
        
    # attempt actual login...
    udb = request.context.get_users_database()
    user = User.get_by_username(udb, username)
        
    if user is None: 
        return HttpResponse(status=401)
    
    if not user.check_password(password):
        return HttpResponse(status=401)
        
    # password was good, record in session
    request.context.set_session_user(user)

    if 'next' in params:
        req = HttpResponse(status=304)
        req.location = params['next']
        return req
    else: 
        return HttpResponse()

    def __call__(self, req):
        if req.headers.get("X-Auth-Token"):
            # already has auth token
            pass
        else:
            # We expire the token every 10 minutes
            if time.time() - self.token_timestamp >= 600000:
                self.token_timestamp = time.time()
                self.token = None

            self.access_resource(req)

        if req.path == self.auth_id:
            res = Response()
            res.status = 200
            res.headers["Content-Type"] = "text/plain"
            res.body = str(self.tenant_id) + "\r\n"
            return res
        else:
            if self.sub_tenant_id:
                parts = req.environ.get("PATH_INFO").split("/")
                if len(parts) > 1 and self.tenant_id:
                    parts[1] = self.tenant_id
                    req.environ["PATH_INFO"] = "/".join(parts)
            return self.application

def application(req):
    #doGzip = 0
    #try:
    #    if string.find(os.environ["HTTP_ACCEPT_ENCODING"], "gzip") != -1:
    #        doGzip = 1
    #except:
    #    pass

    treeid = req.params.get("treeid")
    module = req.params.get("module")
    branch = req.params.get("branch")
    mindate = req.params.get("mindate")
    maxdate = req.params.get("maxdate")
    xml_nofiles = req.params.get("xml_nofiles")

    if not treeid or not module or not branch or not mindate or not maxdate:
        raise exc.HTTPBadRequest("ERROR")

    url = bonsai + "?" + "branchtype=match&sortby=Date&date=explicit&cvsroot=%2Fcvsroot&xml=1"
    url += "&treeid=%s&module=%s&branch=%s&mindate=%s&maxdate=%s" % (quote(treeid), quote(module), quote(branch), quote(mindate), quote(maxdate))

    if xml_nofiles:
        url += "&xml_nofiles=1"

    urlstream = urllib.urlopen(url)
    resp = Response(content_type='text/xml')
    for s in urlstream:
        resp.write(s)
    urlstream.close()
    return resp

        def wrapped(environ, start_response):
            if auth and 'REMOTE_USER' not in environ:
                response = Response(status='401')
                _add_base_headers(response)
                return response(environ, start_response)

            config.c.stats.incr("requests_DATE")
            config.c.stats.incr("requests")

            request = BespinRequest(environ)
            response = BespinResponse(environ, start_response)
            skip_test = environ.get("BespinTestApp")

            if not skip_token_check and skip_test != "True":
                cookie_token = request.cookies.get("Domain-Token")
                header_token = environ.get("HTTP_X_DOMAIN_TOKEN")

                if cookie_token is None or header_token != cookie_token:
                    log.error("request.url=%s" % request.url)
                    log.error("cookies[Domain-Token]=%s" % cookie_token)
                    log.error("headers[X-Domain-Token]=%s" % header_token)
                    log.error("ERROR! The anti CSRF attack trip wire just went off. If you see this message and no-one is hacking you, please tell [email protected]")
                    config.c.stats.incr("csrf_fail_DATE")

            user = request.user
            _add_base_headers(response)
            try:
                return func(request, response)
            except filesystem.NotAuthorized, e:
                response.error("401 Not Authorized", e)

        def __call__(self, environ, start_response):
            try:
                return self.app(environ, start_response)
            except Exception as exc:
                # get a formatted exception
                out = StringIO()
                print_exc(file=out)
                LOG.exception(exc)

                # get formatted WSGI environment
                formatted_environ = pformat(environ)

                # render our template
                result = debug_template.render(
                    traceback=out.getvalue(),
                    environment=formatted_environ
                )

                # construct and return our response
                response = Response()
                if isinstance(exc, HTTPException):
                    response.status_int = exc.status
                else:
                    response.status_int = 500
                response.unicode_body = result
                return response(environ, start_response)

def structured_text_view(context, request):
    """ Filesystem-based STX view
    """
    result = stx2html(context.source)
    response = Response(result)
    response.content_type = 'text/html'
    return response

 def __call__(self, env, start_response):
     """ """
     req = Request(env)
     real_path = '/' + '/'.join(req.path.split('/')[2:])
     #print real_path
     if not self.is_keystone_req(req):
         self.logger.info('pass through')
         return self.app(env, start_response)
     if self.is_keystone_auth_token_req(req):
         self.logger.info('return auth response that merged one and other')
         mbody, mheaders = self.relay_keystone_auth_req(req, real_path)             
         #print 'mbody in keystone_merge: %s' % mbody
         if mbody:
             merged_resp = Response(request=req, 
                                    body=mbody, 
                                    headers=mheaders)
             start_response(merged_resp.status, merged_resp.headerlist)
             return json.dumps(merged_resp.body)
         else:
             return self.app(env, start_response)
     self.logger.info('normal keystone request to one')
     result = self.relay_keystone_ordinary_req(req)
     resp = Response(status='%s %s' % (result.status, result.reason));
     resp.headerlist = result.getheaders()
     resp.body = result.read()
     start_response(resp.status, resp.headerlist)
     return resp.body

def make_response(obj, _content_type='application/json'):
    res = Response(content_type=_content_type)
    if _content_type=="application/json":
        res.body = dumps(obj)
    else:
        res.body = obj
    return res

            def action():
                if auth and 'REMOTE_USER' not in environ:
                    response = Response(status='401')
                    _add_base_headers(response)
                    reply.append(response(environ, start_response))
                    return

                config.c.stats.incr("requests_DATE")
                config.c.stats.incr("requests")

                request = BespinRequest(environ)
                response = BespinResponse(environ, start_response)
                skip_test = environ.get("BespinTestApp")

                if not skip_token_check and skip_test != "True":
                    cookie_token = request.cookies.get("Domain-Token")
                    header_token = environ.get("HTTP_X_DOMAIN_TOKEN")

                    if cookie_token is None or header_token != cookie_token:
                        log.error("request.url=%s" % request.url)
                        log.error("cookies[Domain-Token]=%s" % cookie_token)
                        log.error("headers[X-Domain-Token]=%s" % header_token)
                        log.error("WARNING: The anti CSRF attack trip wire just went off. This means an unprotected request has been made. This could be a hacking attempt, or incomplete protection. The request has NOT been halted")
                        config.c.stats.incr("csrf_fail_DATE")

                # Do we need to do this?
                user = request.user
                _add_base_headers(response)
                try:
                    reply.append(func(request, response))
                    return
                except filesystem.NotAuthorized, e:
                    response.error("401 Not Authorized", e)

	def svResume(self,req,id,sv_inst_id,body=None):
		res = Response(None,200)
		try:
			self.svinstanc_mgr.resume(sv_inst_id)
		except NUllResourceIDException,e:
			Logger.error(e.message)
			res.status=404

def file_response(path):
    resp = Response()
    if exists(path):
        resp.app_iter = FileIterator(path)
    else:
        raise exc.HTTPNotFound("No file found with path %s." % path)
    return resp

def application(environ, start_response):
    req = Request(environ)
    res = Response()
    res.status = 200
    res.headerlist = [('Content-Type','text/html')]
    res.body = "<h1>Hello World!<h1>"
    return res(environ, start_response)

 def get(self):
     # TODO: move translations handling to BaseController
     translation = list(self.request.accept_language)[0]
     view = BoruvkaAuthLoginView(translation)
     response = Response()
     response.body = view.render()
     return response

 def __init__(self, status=400, location='body', name='', description=''):
     body = {'status': status, 'errors':
             [{'location': location, 'name': name, 'description': description}]
             }
     Response.__init__(self, json.dumps(body))
     self.status = status
     self.content_type = 'application/json'

    def post(self):
        params = self.request.params
        api = BoruvkaAuthApi(self.dao)
        request_dict = {}
        for key, value in params.items():
            request_dict[key] = value
        user_id, token_value = api.login(
            payload=request_dict,
        )

        if user_id:
            self.session['user_id'] = user_id
            response = exc.HTTPMovedPermanently(location=self.request.application_url)
            response.set_cookie(
                name='Token',
                value=token_value,
            )
            self.session.save()
            self.session.persist()
            return response
        else:
            # TODO: move translations handling to BaseController
            translation = list(self.request.accept_language)[0]
            view = BoruvkaAuthLoginView(translation)
            view.error = "Unauthorized"
            response = Response()
            response.body = view.render()
            #response = exc.HTTPUnauthorized()
        return response

    def export_notes(self, request, suffix=''):
        """ Return an pdf export of user and public notes

        Returns:
            response

        """ 
        res = Response()
        student = self.__get_current_user()

        try:
            timecoded_data_set = self.__list_notes()
            timecoded_data_array = []

            for timecoded_data in timecoded_data_set:
                timecoded_data_array.append([timecoded_data.seconds, Paragraph(timecoded_data.content.replace('\n','<br />'), ParagraphStyle("Page"))])


            res.headerlist = [('Content-type', 'application/pdf'), ('Content-Disposition', 'attachment; filename=%s' % str(self.scope_ids.user_id)+".pdf")]
            p = canvas.Canvas(res)
            if (len(timecoded_data_array)>0):
                table = Table(timecoded_data_array, colWidths=[20, 500])
                table.setStyle(TableStyle([('INNERGRID', (0, 0), (-1, -1), 0.25, colors.black),
                                            ('BOX', (0, 0), (-1, -1), 0.25, colors.black)]))
                
                table.wrapOn(p, 700, 700)
                table.drawOn(p, 50, 700)
                
            p.showPage()
            p.save()

            return res
        except KNoteList.DoesNotExist:
            res.status = 404
            return res

def get_err_response(code):
    """
    Given an HTTP response code, create a properly formatted xml error response

    :param code: error code
    :returns: webob.response object
    """
    error_table = {
        'AccessDenied':
            (HTTP_FORBIDDEN, 'Access denied'),
        'BucketAlreadyExists':
            (HTTP_CONFLICT, 'The requested bucket name is not available'),
        'BucketNotEmpty':
            (HTTP_CONFLICT, 'The bucket you tried to delete is not empty'),
        'InvalidArgument':
            (HTTP_BAD_REQUEST, 'Invalid Argument'),
        'InvalidBucketName':
            (HTTP_BAD_REQUEST, 'The specified bucket is not valid'),
        'InvalidURI':
            (HTTP_BAD_REQUEST, 'Could not parse the specified URI'),
        'NoSuchBucket':
            (HTTP_NOT_FOUND, 'The specified bucket does not exist'),
        'SignatureDoesNotMatch':
            (HTTP_FORBIDDEN, 'The calculated request signature does not '\
            'match your provided one'),
        'NoSuchKey':
            (HTTP_NOT_FOUND, 'The resource you requested does not exist')}

    resp = Response(content_type='text/xml')
    resp.status = error_table[code][0]
    resp.body = error_table[code][1]
    resp.body = '<?xml version="1.0" encoding="UTF-8"?>\r\n<Error>\r\n  ' \
                '<Code>%s</Code>\r\n  <Message>%s</Message>\r\n</Error>\r\n' \
                 % (code, error_table[code][1])
    return resp

    def handle_request(self, req):
        if (req.method == 'GET'):
            resp = Response(request=req)
            resp.body = 'you send GET method'
	    pprint(req.environ)
	    print req.body
            return resp