Python app_log.warn函数代码示例

    def reraise_client_error(self, exc):
        """Remote fetch raised an error"""
        try:
            url = exc.response.request.url.split('?')[0]
            body = exc.response.body.decode('utf8', 'replace').strip()
        except AttributeError:
            url = 'url'
            body = ''

        msg = self.client_error_message(exc, url, body)

        slim_body = escape(body[:300])

        app_log.warn("Fetching %s failed with %s. Body=%s", url, msg, slim_body)
        if exc.code == 599:
            if isinstance(exc, CurlError):
                en = getattr(exc, 'errno', -1)
                # can't connect to server should be 404
                # possibly more here
                if en in (pycurl.E_COULDNT_CONNECT, pycurl.E_COULDNT_RESOLVE_HOST):
                    raise web.HTTPError(404, msg)
            # otherwise, raise 400 with informative message:
            raise web.HTTPError(400, msg)
        if exc.code >= 500:
            # 5XX, server error, but not this server
            raise web.HTTPError(502, msg)
        else:
            # client-side error, blame our client
            if exc.code == 404:
                raise web.HTTPError(404, "Remote %s" % msg)
            else:
                raise web.HTTPError(400, msg)

    def get(self, path):

        localfile_path = os.path.abspath(
            self.settings.get('localfile_path', ''))

        abspath = os.path.abspath(os.path.join(
            localfile_path,
            path
        ))

        app_log.info("looking for file: '%s'" % abspath)

        if not abspath.startswith(localfile_path):
            app_log.warn("directory traversal attempt: '%s'" % localfile_path)
            raise web.HTTPError(404)

        if not os.path.exists(abspath):
            raise web.HTTPError(404)

        with io.open(abspath, encoding='utf-8') as f:
            nbdata = f.read()

        yield self.finish_notebook(nbdata, download_url=path,
                                   msg="file from localfile: %s" % path,
                                   public=False,
                                   format=self.format,
                                   request=self.request)

 def get_error_html(self, status_code, **kwargs):
     """render custom error pages"""
     exception = kwargs.get('exception')
     message = ''
     status_message = responses.get(status_code, 'Unknown')
     if exception:
         # get the custom message, if defined
         try:
             message = exception.log_message % exception.args
         except Exception:
             pass
         
         # construct the custom reason, if defined
         reason = getattr(exception, 'reason', '')
         if reason:
             status_message = reason
     
     # build template namespace
     ns = dict(
         status_code=status_code,
         status_message=status_message,
         message=message,
         exception=exception,
     )
     
     # render the template
     try:
         html = self.render_template('%d.html' % status_code, **ns)
     except Exception as e:
         app_log.warn("No template for %d", status_code)
         html = self.render_template('error.html', **ns)
     return html

def wait_for_http_server(url, timeout=10):
    """Wait for an HTTP Server to respond at url
    
    Any non-5XX response code will do, even 404.
    """
    loop = ioloop.IOLoop.current()
    tic = loop.time()
    client = AsyncHTTPClient()
    while loop.time() - tic < timeout:
        try:
            r = yield client.fetch(url, follow_redirects=False)
        except HTTPError as e:
            if e.code >= 500:
                # failed to respond properly, wait and try again
                if e.code != 599:
                    # we expect 599 for no connection,
                    # but 502 or other proxy error is conceivable
                    app_log.warn("Server at %s responded with error: %s", url, e.code)
                yield gen.Task(loop.add_timeout, loop.time() + 0.25)
            else:
                app_log.debug("Server at %s responded with %s", url, e.code)
                return
        except (OSError, socket.error) as e:
            if e.errno not in {errno.ECONNABORTED, errno.ECONNREFUSED, errno.ECONNRESET}:
                app_log.warn("Failed to connect to %s (%s)", url, e)
            yield gen.Task(loop.add_timeout, loop.time() + 0.25)
        else:
            return
    
    raise TimeoutError("Server at {url} didn't respond in {timeout} seconds".format(
        **locals()
    ))

    def _log_rate_limit(self, future):
        """log GitHub rate limit headers
        
        - error if 0 remaining
        - warn if 10% or less remain
        - debug otherwise
        """
        try:
            r = future.result()
        except HTTPError as e:
            r = e.response
        limit_s = r.headers.get("X-RateLimit-Limit", "")
        remaining_s = r.headers.get("X-RateLimit-Remaining", "")
        if not remaining_s or not limit_s:
            if r.code < 300:
                app_log.warn("No rate limit headers. Did GitHub change? %s", json.dumps(r.headers, indent=1))
            return

        remaining = int(remaining_s)
        limit = int(limit_s)
        if remaining == 0:
            jsondata = response_text(r)
            data = json.loads(jsondata)
            app_log.error("GitHub rate limit (%s) exceeded: %s", limit, data.get("message", "no message"))
            return

        if 10 * remaining > limit:
            log = app_log.debug
        else:
            log = app_log.warn
        log("%i/%i GitHub API requests remaining", remaining, limit)

    def write_error(self, status_code, **kwargs):
        """render custom error pages"""
        exc_info = kwargs.get('exc_info')
        message = ''
        status_message = responses.get(status_code, 'Unknown')
        if exc_info:
            # get the custom message, if defined
            exception = exc_info[1]
            try:
                message = exception.log_message % exception.args
            except Exception:
                pass

            # construct the custom reason, if defined
            reason = getattr(exception, 'reason', '')
            if reason:
                status_message = reason

        # build template namespace
        ns = dict(
            status_code=status_code,
            status_message=status_message,
            message=message,
            exception=exception,
        )

        # render the template
        try:
            html = self.render_template('%d.html' % status_code, **ns)
        except Exception as e:
            app_log.warn("No template for %d", status_code)
            html = self.render_template('error.html', **ns)
        self.set_header('Content-Type', 'text/html')
        self.write(html)

 def reraise_client_error(self, exc):
     """Remote fetch raised an error"""
     try:
         url = exc.response.request.url
     except AttributeError:
         url = 'url'
     app_log.warn("Fetching %s failed with %s", url, exc)
     if exc.code == 599:
         str_exc = str(exc)
         # strip the unhelpful 599 prefix
         if str_exc.startswith('HTTP 599: '):
             str_exc = str_exc[10:]
         if isinstance(exc, CurlError):
             en = getattr(exc, 'errno', -1)
             # can't connect to server should be 404
             # possibly more here
             if en in (pycurl.E_COULDNT_CONNECT, pycurl.E_COULDNT_RESOLVE_HOST):
                 raise web.HTTPError(404, str_exc)
         # otherwise, raise 400 with informative message:
         raise web.HTTPError(400, str_exc)
     if exc.code >= 500:
         # 5XX, server error, but not this server
         raise web.HTTPError(502, str(exc))
     else:
         if exc.code == 404:
             raise web.HTTPError(404, "Remote %s" % exc)
         else:
             # client-side error, blame our client
             raise web.HTTPError(400, str(exc))

	def add_friend(self, friend):
		if not self.check_friend(friend):
			_conn.execute('''INSERT INTO tbl_friends (f_user_id, friend_id) VALUES (?, ?)''', (self.user_id, friend.user_id))
			_conn.commit()
		else:
			app_log.warn("{!r} is already a friend of {!r}".format(friend.username, self.username))
			raise FriendAlreadyAdded('{} has already been added as a friend of {}'.format(friend.username, self.username))

    def get(self, path):

        localfile_path = os.path.abspath(
            self.settings.get('localfile_path', ''))

        abspath = os.path.abspath(os.path.join(
            localfile_path,
            path
        ))

        app_log.info("looking for file: '%s'" % abspath)

        if not abspath.startswith(localfile_path):
            app_log.warn("directory traversal attempt: '%s'" % localfile_path)
            raise web.HTTPError(404)

        if not os.path.exists(abspath):
            raise web.HTTPError(404)
        if not os.path.isfile(abspath):
            base_url='/localfile'
            contents=os.listdir(abspath)
            dirs=[]
            others=[]
            ipynbs=[]
            entries=[]
            for c in contents:
                e={}
                e['name']=c 
                e['url']=os.path.join(base_url,path,c)
                subpath=os.path.join(abspath,c)
                if os.path.isdir(subpath):
                    e['class']='fa-folder-open'
                    dirs.append(e)
                elif os.path.isfile(subpath):
                    if c.endswith('.ipynb'):
                        e['class']='fa-book'
                        ipynbs.append(e)
                    else:
                        e['url']='javascript:alert("not allowed type!");'
                        e['class']='fa-folder-close'
                        others.append(e)
            entries.extend(dirs)
            entries.extend(ipynbs)
            entries.extend(others)
            breadcrumbs=self.breadcrumbs(path,base_url)
            html=self.render_template('treelist.html',
                entries=entries,breadcrumbs=breadcrumbs,tree_type='localfile',
                tree_label='localfiels')
            yield self.cache_and_finish(html)
        else:
            with io.open(abspath, encoding='utf-8') as f:
                nbdata = f.read()
            provider_url=os.path.join(base_url,path)
            yield self.finish_notebook(nbdata, download_url=path,
                                        provider_url=provider_url,
                                       msg="file from localfile: %s" % path,
                                       public=False,
                                       format=self.format,
                                       request=self.request)

	def find_uid(cls, uid):
		cur = _conn.execute('''SELECT rowid AS user_id, fname, lname, username, email, image, dob FROM tbl_users WHERE rowid = ? LIMIT 1''', (uid,))
		row = cur.fetchone()

		if not row:
			app_log.warn("user with the uid {} could not be found".format(uid))
			raise UserNotFound('Uid {} does not exist'.format(uid))

		return cls(**row)

	def find(cls, product_id):
		cur = _conn.execute('''SELECT p.rowid AS product_id, p.name, p.image, p.link, p.description, p.price, i.checked FROM tbl_products AS p LEFT JOIN tbl_list_item AS i ON p.rowid = i.product_id WHERE p.rowid = ? LIMIT 1''', (product_id,))
		row = cur.fetchone()

		if not row:
			app_log.warn("product {} could not be found".format(product_id))
			raise ProductNotFound('{} does not exist'.format(product_id))

		return cls(*row)

    def on_finish(self):
        if self._pkg_fd is not None:
            self._pkg_fd.close()

        # md5_digest content not found
        if self._need_md5:
            app_log.warn('md5_digest disposition not found')
            self._pkg_md5 = self._pkg_diggest.hexdigest()
            self.write_md5()

    def create_notebook_server(self, base_path,
                               image="jupyter/demo",
                               ipython_executable="ipython3",
                               mem_limit="512m",
                               cpu_shares="1",
                               container_ip="127.0.0.1",
                               container_port=8888):
        '''
        Creates a notebook_server running off of `base_path`.

        returns the container_id, ip, port in a Future
        '''

        templates = ['/srv/ga',
                     '/srv/ipython/IPython/html',
                     '/srv/ipython/IPython/html/templates']

        tornado_settings = {'template_path': templates}

        ipython_args = [
                "notebook", "--no-browser",
                "--port {}".format(container_port),
                "--ip=0.0.0.0",
                "--NotebookApp.base_url=/{}".format(base_path),
                "--NotebookApp.tornado_settings=\"{}\"".format(tornado_settings)
        ]

        ipython_command = ipython_executable + " " + " ".join(ipython_args)

        command = [
            "/bin/sh",
            "-c",
            ipython_command
        ]

        resp = yield self.docker_client.create_container(image=image,
                                                    command=command,
                                                    mem_limit=mem_limit,
                                                    cpu_shares=cpu_shares)

        docker_warnings = resp['Warnings']
        if docker_warnings is not None:
            app_log.warn(docker_warnings)

        container_id = resp['Id']
        app_log.info("Created container {}".format(container_id))

        yield self.docker_client.start(container_id,
                                       port_bindings={container_port: (container_ip,)})

        container_network = yield self.docker_client.port(container_id,
                                                          container_port)

        host_port = container_network[0]['HostPort']
        host_ip = container_network[0]['HostIp']

        raise gen.Return((container_id, host_ip, int(host_port)))

    def create_notebook_server(self, base_path, container_name, container_config):
        '''Creates a notebook_server running off of `base_path`.

        Returns the (container_id, ip, port) tuple in a Future.'''

        port = container_config.container_port

        app_log.debug(container_config)

        # Assumes that the container_config.command is of a format like:
        #
        #  ipython3 notebook --no-browser --port {port} --ip=0.0.0.0
        #    --NotebookApp.base_path=/{base_path}
        #    --NotebookApp.tornado_settings=\"{ \"template_path\": [ \"/srv/ga\",
        #    \"/srv/ipython/IPython/html\",
        #    \"/srv/ipython/IPython/html/templates\" ] }\""
        #
        # Important piece here is the parametrized base_path to let the
        # underlying process know where the proxy is routing it.
        rendered_command = container_config.command.format(base_path=base_path, port=port)

        command = [
            "/bin/sh",
            "-c",
            rendered_command
        ]

        resp = yield self._with_retries(self.docker_client.create_container,
                                        image=container_config.image,
                                        command=command,
                                        mem_limit=container_config.mem_limit,
                                        cpu_shares=container_config.cpu_shares,
                                        name=container_name)

        docker_warnings = resp['Warnings']
        if docker_warnings is not None:
            app_log.warn(docker_warnings)

        container_id = resp['Id']
        app_log.info("Created container {}".format(container_id))

        port_bindings = {
            container_config.container_port: (container_config.container_ip,)
        }
        yield self._with_retries(self.docker_client.start,
                                 container_id,
                                 port_bindings=port_bindings)

        container_network = yield self._with_retries(self.docker_client.port,
                                                     container_id,
                                                     container_config.container_port)

        host_port = container_network[0]['HostPort']
        host_ip = container_network[0]['HostIp']

        raise gen.Return((container_id, host_ip, int(host_port)))

    def cleanout(self):
        '''Completely cleanout containers that are part of this pool.'''
        app_log.info("Performing initial pool cleanup")

        containers = yield self.spawner.list_notebook_servers(self.container_name_pattern, all=True)
        for container in containers:
            try:
                app_log.debug("Clearing old container [%s] from pool", container['Id'])
                yield self.spawner.shutdown_notebook_server(container['Id'])
            except Exception as e:
                app_log.warn(e)