コード例 #1
0
def test_connect(c, s, a, b):
    future = c.submit(lambda x: x + 1, 1)
    x = c.submit(slowinc, 1, delay=1, retries=5)
    yield future
    http_client = AsyncHTTPClient()
    for suffix in ['info/main/workers.html',
                   'info/worker/' + url_escape(a.address) + '.html',
                   'info/task/' + url_escape(future.key) + '.html',
                   'info/main/logs.html',
                   'info/logs/' + url_escape(a.address) + '.html',
                   'info/call-stack/' + url_escape(x.key) + '.html',
                   'info/call-stacks/' + url_escape(a.address) + '.html',
                   'json/counts.json',
                   'json/identity.json',
                   'json/index.html',
                   'individual-plots.json',
                   ]:
        response = yield http_client.fetch('http://localhost:%d/%s'
                                           % (s.services['bokeh'].port, suffix))
        assert response.code == 200
        body = response.body.decode()
        if suffix.endswith('.json'):
            json.loads(body)
        else:
            assert xml.etree.ElementTree.fromstring(body) is not None
            assert not re.search("href=./", body)  # no absolute links
コード例 #2
0
ファイル: auth_handlers.py プロジェクト: DarcyMyers/qiita
    def post(self):
        username = self.get_argument("email", "").strip().lower()
        password = self.get_argument("newpass", "")
        info = {}
        for info_column in ("name", "affiliation", "address", "phone"):
            hold = self.get_argument(info_column, None)
            if hold:
                info[info_column] = hold

        created = False
        try:
            created = User.create(username, password, info)
        except QiitaDBDuplicateError:
            msg = "Email already registered as a user"

        if created:
            info = created.info
            try:
                send_email(username, "QIITA: Verify Email Address", "Please "
                           "click the following link to verify email address: "
                           "%s/auth/verify/%s?email=%s"
                           % (qiita_config.base_url, info['user_verify_code'],
                              url_escape(username)))
            except:
                msg = ("Unable to send verification email. Please contact the "
                       "qiita developers at <a href='mailto:qiita-help"
                       "@gmail.com'>[email protected]</a>")
                self.redirect(u"/?level=danger&message=" + url_escape(msg))
                return
            self.redirect(u"/")
        else:
            error_msg = u"?error=" + url_escape(msg)
            self.redirect(u"/auth/create/" + error_msg)
コード例 #3
0
ファイル: utils.py プロジェクト: acieroid/imdb
def work_link(ID):
    """Return an HTML link for the work designed by ID (using /serie/
    for a serie, /movie/ for a movie and /episode/ for an episode)"""
    if ID[0] != '"':
        # Movie
        res = re.search('^(.+) \(([0-9]{4})[^\)]*\)', ID)
        if res:
            title = escape(res.group(1))
            year = escape(res.group(2))
            return ('<a href="/movie/%s">%s (%s)</a>' % (url_escape(ID), title, year))
        else:
            return ('Invalid movie ID: %s' % escape(ID))
    elif ID.find('{') != -1:
        # Episode
        res = re.search('^"(.+)" \(([0-9]{4})[^\)]*\) \{([^\(]*)(\(#([0-9]{1,3})\.([0-9]{1,3})\))?\}', ID)
        if res:
            title = escape(res.group(1))
            year = escape(res.group(2))
            epi_name = escape(res.group(3))
            season = escape(res.group(5) or '')
            epi_num = escape(res.group(6) or '')
            return ('<a href="/episode/%s">%s (%s) %sx%s: %s</a>' % (url_escape(ID), title, year, season, epi_num, epi_name))
        else:
            return ('Invalid episode ID: %s' % escape(ID))
    else:
        # Serie
        res = re.search('"(.+)" \(([0-9]{4})[^\)]*\)', ID)
        if res:
            title = escape(res.group(1))
            year = escape(res.group(2))
            return ('<a href="/serie/%s">%s (%s)</a>' % (url_escape(ID), title, year))
        else:
            return ('Invalid serie ID: %s' % escape(ID))
コード例 #4
0
ファイル: manage.py プロジェクト: cloveses/stir-mentality
 def post(self):
     para_keys=('name','ps','psbak')
     para_dict={}
     mgr_code_u = self.get_argument('mgr_code',default='')
     if mgr_code_u and mgr_code_u==mgr_code:
         usertype = 1
     else:
         usertype = 0
     for key in para_keys:
         para_dict.update({key:self.get_argument(key,default='')})
     if all(para_dict.values()):
         if para_dict['ps']==para_dict['psbak']:
             astu = Stu(name=para_dict['name'],psswd=para_dict['ps'],usertype=usertype)
             if astu.had_name():
                 self.redirect('/signup?msg='+url_escape("用户名已经被注册!"))
                 return
             astu.save()
             re = Stu(name=para_dict['name'],psswd=para_dict['ps']).isRgstr()
             if re:
                 self.set_secure_cookie('name',str(re[1]))
                 self.set_secure_cookie('id',str(re[0]))
                 self.set_secure_cookie('usertype',str(re[3]))
             self.redirect('/')
         else:
             self.redirect('/signup?msg='+url_escape("密码不匹配"))
     else:
         self.redirect('/signup?msg='+url_escape("参数不全"))
コード例 #5
0
ファイル: manage.py プロジェクト: cloveses/stir-mentality
 def post(self,sbjct_id):
     all_sbjcts = StuSbjct().getSbjcts()
     crrnt_sbjct = self.getCrrntSbjct(all_sbjcts,sbjct_id) if all_sbjcts else ()
     name = self.get_argument("name",default='')
     psswd = self.get_argument("psswd",default='')
     if name and psswd:
         re = Stu(name=name,psswd=psswd,ipaddr=self.request.remote_ip).isRgstr()
         # print(self.request.remote_ip)
         if re:
             self.set_secure_cookie('name',str(re[1]))
             self.set_secure_cookie('id',str(re[0]))
             self.set_secure_cookie('usertype',str(re[3]))
             if crrnt_sbjct and (crrnt_sbjct[3] or re[3]):
                 all_answrs = StuAnswr().getAnswrs(crrnt_sbjct[0])
             elif crrnt_sbjct:
                 all_answrs = StuAnswr().getSelfAnswr(crrnt_sbjct[0],int(re[0]))
             else:
                 all_answrs = []
             all_hlp_self = self.getHlps()
             self.render('index.html',dict(stu_id=re[0],name=name,usertype=re[3],
                 all_sbjcts=all_sbjcts,crrnt_sbjct=crrnt_sbjct,info='',
                 all_answrs=all_answrs,all_hlp_self=all_hlp_self))
         else:
             self.redirect('/?info=' + url_escape("登录失败!"))
     else:
         self.redirect('/?info=' + url_escape("登录失败!"))
コード例 #6
0
 def _render(self, login_error=None, username=None):
     return self.render_template('login.html',
             next=url_escape(self.get_argument('next', default='')),
             repourl=url_escape(self.get_argument('repourl', default='')),
             username=username,
             login_error=login_error,
     )
コード例 #7
0
ファイル: handlers.py プロジェクト: mhmurray/cloaca
    def post(self):
        try:
            username = self.get_argument('username')

            # TODO: replace with JWT from OpenID Connect
            auth = self.get_argument('auth')
        except tornado.web.MissingArgumentError:
            self.write('Must specify username and auth.')
            return

        user_id = yield self.db.retrieve_user_id_from_username(username)
        if user_id is None:
            self.redirect('/login?error={0}'
                    .format(escape.url_escape('Unknown username or password.')))
        else:
            user_auth = yield self.db.retrieve_user_auth(user_id)
            hashed_auth = yield pool.submit(
                    bcrypt.hashpw, auth.encode('utf-8'), user_auth.encode('utf-8'))

            if user_auth == hashed_auth:
                session_auth = yield self.db.retrieve_user_session_auth(user_id)
                self.set_secure_cookie('session_auth', session_auth,
                        expires_days=SESSION_MAX_AGE_DAYS)
                self.redirect('/')
            else:
                self.redirect('/login?error={0}'
                        .format(escape.url_escape(
                            'Unknown username or password.')))
コード例 #8
0
ファイル: middleware.py プロジェクト: jstacoder/oz
 def set_blink(self, message, type="info"):
     """
     Sets the blink, a one-time transactional message that is shown on the
     next page load
     """
     self.set_cookie("blink_message", escape.url_escape(message), httponly=True)
     self.set_cookie("blink_type", escape.url_escape(type), httponly=True)
コード例 #9
0
ファイル: authenticator.py プロジェクト: RPraneetha/everware
 def _render(self, login_error=None, username=None):
     return self.render_template(
         "login.html",
         next=url_escape(self.get_argument("next", default="")),
         repourl=url_escape(self.get_argument("repourl", default="")),
         username=username,
         login_error=login_error,
     )
コード例 #10
0
ファイル: AF_Tool.py プロジェクト: deju/afw_old
def send_mail_reset(to, token, name):
    subject = u'子曰--密码重置'
    html = (u"<html><head></head><body>"
            u"<p>" + name + u",您对密码进行了重置,请您点击下面链接完成密码重置操作!</p><br>"
            u"<p><a href='http://www.afewords.com/check?type=reset&email=" + url_escape(to)+ u"&token="+ token +u"'>重置链接</a></p>"
            u"<p>或者将链接复制至地址栏完成密码重置:http://www.afewords.com/check?type=reset&email="+url_escape(to)+"&token=" + token + u"</p>"
            u"<body></html>")
    return send_mail(to, subject, html)
コード例 #11
0
ファイル: couch.py プロジェクト: dgquintas/my-code-samples
 def delete_attachment(self, doc, attachment_name):
     '''Delete a named attachment to the specified doc.
     The doc shall be a dict, at least with the keys: _id and _rev'''
     if '_rev' not in doc or '_id' not in doc:
         raise KeyError('Missing id or revision information in doc')
     url = '/{0}/{1}/{2}?rev={3}'.format(self.db_name,
             url_escape(doc['_id']), url_escape(attachment_name),
             doc['_rev'])
     return self._http_delete(url)
コード例 #12
0
ファイル: AF_Tool.py プロジェクト: deju/afw_old
def send_mail_reg(to, token, name):   
    subject = u'子曰--验证注册'
    html = (u"<html><head></head><body>"
        u"<p>" + name + u",欢迎您注册子曰,请您点击下面链接进行邮箱验证操作!</p>"
        u"<br>"
        u"<p><a href='http://www.afewords.com/check?email="+ url_escape(to)+ u"&token=" + token + u"'>验证链接</a></p><br>"
        u"<p>或者将链接复制至地址栏完成邮箱激活:http://www.afewords.com/check?email="+url_escape(to)+"&token=" + token + u"</p>"
        u"</body></html>")
    return send_mail(to, subject, html)
コード例 #13
0
ファイル: __init__.py プロジェクト: BrainsInJars/Queen-Bee
		def params(param):
			key, value = param
			if value is None:
				return

			key = escape.url_escape(str(key))
			value = escape.url_escape(str(value))

			self.log.info((key, value))

			return '%s=%s' % (key, value)
コード例 #14
0
def send_file(file_path, dashboard_name, handler):
    '''
    Posts a file to the Jupyter Dashboards Server to be served as a dashboard
    :param file_path: The path of the file to send
    :param dashboard_name: The dashboard name under which it should be made
        available
    '''
    # Make information about the request Host header available for use in
    # constructing the urls
    segs = handler.request.host.split(':')
    hostname = segs[0]
    if len(segs) > 1:
        port = segs[1]
    else:
        port = ''
    protocol = handler.request.protocol

    # Treat empty as undefined
    dashboard_server = os.getenv('DASHBOARD_SERVER_URL')
    if dashboard_server:
        dashboard_server = dashboard_server.format(protocol=protocol,
            hostname=hostname, port=port)
        upload_url = url_path_join(dashboard_server, UPLOAD_ENDPOINT,
            escape.url_escape(dashboard_name, False))
        with open(file_path, 'rb') as file_content:
            headers = {}
            token = os.getenv('DASHBOARD_SERVER_AUTH_TOKEN')
            if token:
                headers['Authorization'] = 'token {}'.format(token)
            result = requests.post(upload_url, files={'file': file_content},
                headers=headers, timeout=60, 
                verify=not skip_ssl_verification())
            if result.status_code >= 400:
                raise web.HTTPError(result.status_code)

        # Redirect to link specified in response body
        res_body = result.json()
        if 'link' in res_body:
            redirect_link = res_body['link']
        else:
            # Compute redirect link using environment variables
            # First try redirect URL as it might be different from internal upload URL
            redirect_server = os.getenv('DASHBOARD_REDIRECT_URL')
            if redirect_server:
                redirect_root = redirect_server.format(hostname=hostname,
                    port=port, protocol=protocol)
            else:
                redirect_root = dashboard_server

            redirect_link = url_path_join(redirect_root, VIEW_ENDPOINT, escape.url_escape(dashboard_name, False))
        handler.redirect(redirect_link)
    else:
        access_log.debug('Can not deploy, DASHBOARD_SERVER_URL not set')
        raise web.HTTPError(500, log_message='No dashboard server configured')
コード例 #15
0
ファイル: escape_test.py プロジェクト: YoungLeeNENU/tornado
 def test_url_escape_quote_plus(self):
     unescaped = '+ #%'
     plus_escaped = '%2B+%23%25'
     escaped = '%2B%20%23%25'
     self.assertEqual(url_escape(unescaped), plus_escaped)
     self.assertEqual(url_escape(unescaped, plus=False), escaped)
     self.assertEqual(url_unescape(plus_escaped), unescaped)
     self.assertEqual(url_unescape(escaped, plus=False), unescaped)
     self.assertEqual(url_unescape(plus_escaped, encoding=None),
                      utf8(unescaped))
     self.assertEqual(url_unescape(escaped, encoding=None, plus=False),
                      utf8(unescaped))
コード例 #16
0
ファイル: note.py プロジェクト: 01-/magpie
 def _star(self, notebook_name, note_name, star, redir=True):
     starred = self.get_starred()
     full_name = u'%s/%s' % (notebook_name, note_name)
     if star == 'set' and full_name not in starred:
         starred.append(full_name)
     elif star == 'unset' and full_name in starred:
         starred.remove(full_name)
     self.set_cookie('starred_notes',
                     b64encode(','.join(starred).encode('utf8')),
                     expires_days=365)
     if redir:
         self.redirect('/%s/%s' % (url_escape(notebook_name).replace('#', '%23'), url_escape(note_name).replace('#', '%23')))
コード例 #17
0
ファイル: urlargparse.py プロジェクト: dsschult/file_catalog
 def recurse(obj,prefix=''):
     if isinstance(obj,dict):
         for k in obj:
             recurse(obj[k],prefix+'['+k+']')
     elif isinstance(obj,list):
         for i,v in enumerate(obj):
             if isinstance(v,(dict,list)):
                 recurse(v,prefix+'[%d]'%i)
             else:
                 recurse(v,prefix+'[]')
     else:
         ret.append(url_escape(prefix)+'='+url_escape(str(obj)))
コード例 #18
0
ファイル: auth_handlers.py プロジェクト: antgonza/qiita
    def post(self):
        username = self.get_argument("email", "").strip().lower()
        password = self.get_argument("newpass", "")
        info = {}
        for info_column in ("name", "affiliation", "address", "phone"):
            hold = self.get_argument(info_column, None)
            if hold:
                info[info_column] = hold

        created = False
        try:
            created = User.create(username, password, info)
        except QiitaDBDuplicateError:
            msg = "Email already registered as a user"

        if created:
            info = created.info
            try:
                # qiita_config.base_url doesn't have a / at the end, but the
                # qiita_config.portal_dir has it at the beginning but not at
                # the end. This constructs the correct URL
                url = qiita_config.base_url + qiita_config.portal_dir
                send_email(username, "QIITA: Verify Email Address", "Please "
                           "click the following link to verify email address: "
                           "%s/auth/verify/%s?email=%s\n\nBy clicking you are "
                           "accepting our term and conditions: "
                           "%s/iframe/?iframe=qiita-terms"
                           % (url, info['user_verify_code'],
                              url_escape(username), url))
            except Exception:
                msg = ("Unable to send verification email. Please contact the "
                       "qiita developers at <a href='mailto:qiita-help"
                       "@gmail.com'>[email protected]</a>")
                self.redirect(u"%s/?level=danger&message=%s"
                              % (qiita_config.portal_dir, url_escape(msg)))
                return

            msg = ("<h3>User Successfully Created</h3><p>Your Qiita account "
                   "has been successfully created. An email has been sent to "
                   "the email address you provided. This email contains "
                   "instructions on how to activate your account.</p>"
                   "<p>If you don't receive your activation email within a "
                   "couple of minutes, check your spam folder. If you still "
                   "don't see it, send us an email at <a "
                   "href=\"mailto:[email protected]\">[email protected]"
                   "</a>.</p>")
            self.redirect(u"%s/?level=success&message=%s" %
                          (qiita_config.portal_dir, url_escape(msg)))
        else:
            error_msg = u"?error=" + url_escape(msg)
            self.redirect(u"%s/auth/create/%s"
                          % (qiita_config.portal_dir, error_msg))
コード例 #19
0
ファイル: utils.py プロジェクト: acieroid/imdb
def person_info(t, person, ID, admin):
    (fname, lname, num) = person
    res = ('<a href="/person/%s/%s/%s">%s %s</a>' %
           (url_escape(fname), url_escape(lname), url_escape(num),
            url_escape(fname), url_escape(lname)))
    if admin:
        res += (' (<a href="/admin/delete/%s/%s/%s/%s/%s">delete</a>)' %
                (t, url_escape(fname), url_escape(lname), url_escape(num),
                 url_escape(ID)))
    return res
コード例 #20
0
ファイル: manager.py プロジェクト: aphlysia/ahiru
	def run(self):
		book = self.book
		lock = self.lock
		whoToAsk = _setWhoToAsk(self.user, self.whoToAsk, self.book, self.connectAll, self.maxConnection)
		
		http_client = tornado.httpclient.HTTPClient()
		_body = 'userName='******'&userPubKey=' + escape.url_escape(self.user.pubKey)
		_body += '&host=' + escape.url_escape(self.user.host)
		_body += '&port=' + escape.url_escape(str(self.user.port))
		_body += '&invitation=' + escape.url_escape(self.user.invitation if self.user.invitation is not None else ' ')
		_body += '&approverID=' + escape.url_escape(self.user.approverID if self.user.approverID is not None else ' ')
		_body += '&bookID=' + escape.url_escape(self.book.getID())
		_body += '&password='******'http://' + str(user.host) + ':' + str(user.port)
				if self.askMember:
					response = http_client.fetch(address + '/members', method = 'POST', body = _body)
					members = escape.json_decode(response.body)
					_updateMembers(members, self.user, book, lock, address)
				if self.askAction:
					response = http_client.fetch(address + '/versions', method = 'POST', body = _body)
					versions = escape.json_decode(response.body)
					_updateActions(versions, self.user, book, lock, address)
			except tornado.httpclient.HTTPError as e:
				#todo: log
				print("Error:" + str(e))
				pass
			except ValueError:
				print('ValueError')
コード例 #21
0
ファイル: couch.py プロジェクト: dgquintas/my-code-samples
 def save_attachment(self, doc, attachment):
     '''Save an attachment to the specified doc.
     The attachment shall be a dict with keys: `mimetype`, `name`, `data`.
     The doc shall be a dict, at least having the key `_id`, and if doc is
     existing in the database, it shall also contain the key `_rev`'''
     if any(key not in attachment for key in ('mimetype', 'name', 'data')):
         raise KeyError('Attachment dict is missing one or more required '
                 'keys')
     url = '/{0}/{1}/{2}{3}'.format(self.db_name, url_escape(doc['_id']),
             url_escape(attachment['name']),
             '?rev={0}'.format(doc['_rev']) if '_rev' in doc else '')
     headers = {'Content-Type': attachment['mimetype']}
     body = attachment['data']
     return self._http_put(url, body, headers=headers)
コード例 #22
0
ファイル: manager.py プロジェクト: aphlysia/ahiru
def _updateMembers(members, user, book, lock, address):
	lock.acquire()
	ids = [id for id in members if id not in book.members]
	freezeCount = 0
	while ids:
		id = ids.pop(0)
		newcomer = User(**members[id])
		if newcomer.approverID in book.members and User.isValidInvitation(book.members[newcomer.approverID], newcomer, book.getID()):
			book.members[id] = newcomer
			book.versions[id] = 0
			freezeCount = 0
		else:
			freezeCount += 1
			ids.append(id)
			if freezeCount >= len(ids):
				break
	lock.release()
		
	lock.acquire()
	myMembers = dict(book.members)
	lock.release()
	for user in myMembers:
		if user not in members:
			http_client = tornado.httpclient.HTTPClient()
			_body = 'userName='******'&userPubKey=' + escape.url_escape(user.pubKey)
			_body += '&host=' + escape.url_escape(user.host)
			_body += '&port=' + escape.url_escape(str(user.port))
			_body += '&invitation=' + escape.url_escape(user.invitation if user.invitation is not None else ' ')
			_body += '&approverID=' + escape.url_escape(user.approverID if user.approverID is not None else ' ')
			_body += '&bookID=' + escape.url_escape(book.getID())
			_body += '&password='******'/newmembers', method = 'POST', body = _body)
			break
コード例 #23
0
ファイル: manager.py プロジェクト: aphlysia/ahiru
	def run(self):
		books = self.books
		lock = self.lock
			
		http_client = tornado.httpclient.HTTPClient()
		_body = 'userName='******'&userPubKey=' + escape.url_escape(self.user.pubKey)
		_body += '&host=' + escape.url_escape(self.user.host)
		_body += '&port=' + escape.url_escape(str(self.user.port))
		_body += '&bookID=' + escape.url_escape(self.bookID)
		_body += '&invitation=' + escape.url_escape(' ')
		_body += '&approverID=' + escape.url_escape(' ')
		_body += '&password='******'http://' + str(self.host) + ':' + str(self.port)
		try:
			response = http_client.fetch(address + '/join', method = 'POST', body = _body)
			b = escape.json_decode(response.body)
			owner = User(**b['owner'])
			lock.acquire()
			book = Book.copyCover(owner, b['title'], b['signature'], b['createdAt'], self.path)
			books[book.getID()] = book
			lock.release()
			
			response = http_client.fetch(address + '/members', method = 'POST', body = _body)
			members = escape.json_decode(response.body)
			_updateMembers(members, self.user, book, lock, address)
		except tornado.httpclient.HTTPError as e:
			#todo: log
			print("Error:" + str(e))
		except ValueError:
			print('ValueError')
コード例 #24
0
ファイル: handlers.py プロジェクト: sagemath/sagecell
 def get(self):
     logger.debug('RootHandler.get')
     args = self.request.arguments
     code = None
     lang = self.get_argument("lang", None)
     interacts = None
     if "c" in args:
         # The code is explicitly specified
         code = self.get_argument("c")
     elif "z" in args:
         # The code is base64-compressed
         def get_decompressed(name):
             a = args[name][-1]
             # We allow the user to strip off the ``=`` padding at the end
             # so that the URL doesn't have to have any escaping.
             # Here we add back the ``=`` padding if we need it.
             a += "=" * ((4 - (len(a) % 4)) % 4)
             return zlib.decompress(
                 base64.urlsafe_b64decode(a)).decode("utf8")
             
         try:
             code = get_decompressed("z")
             if "interacts" in args:
                 interacts = get_decompressed("interacts")
         except Exception as e:
             self.set_status(400)
             self.finish("Invalid zipped code: %s\n" % (e.message,))
             return
     elif "q" in args:
         # The code is referenced by a permalink identifier.
         q = self.get_argument("q")
         try:
             code, lang, interacts = (yield tornado.gen.Task(
                 self.application.db.get, q))[0]
         except LookupError:
             logger.warning("ID not found in permalink database %s", q)
             self.set_status(404)
             self.finish("ID not found in permalink database")
             return
     if code is not None:
         code = url_escape(code, plus=False)
     if interacts is not None:
         interacts = url_escape(interacts, plus=False)
     autoeval = self.get_argument(
         "autoeval", "false" if code is None else "true" )
     self.render(
         "root.html",
         code=code, lang=lang, interacts=interacts, autoeval=autoeval)
コード例 #25
0
 def test_get_not_authed(self):
     response = self.get('/ag_new_barcode/')
     self.assertEqual(response.code, 200)
     port = self.get_http_port()
     self.assertEqual(response.effective_url,
                      'http://localhost:%d/login/?next=%s' %
                      (port, url_escape('/ag_new_barcode/')))
コード例 #26
0
ファイル: project.py プロジェクト: HarrisonHDU/poweredsites
    def post(self):
        fm = ProjectPreForm(self)

        if fm.validate():
            self.redirect("/submit/project?url=%s" % escape.url_escape(fm._values["website"]))
        else:
            fm.render("project/submit_pre.html")
コード例 #27
0
ファイル: handlers.py プロジェクト: Fitz3012/notebook
def respond_zip(handler, name, output, resources):
    """Zip up the output and resource files and respond with the zip file.

    Returns True if it has served a zip file, False if there are no resource
    files, in which case we serve the plain output file.
    """
    # Check if we have resource files we need to zip
    output_files = resources.get("outputs", None)
    if not output_files:
        return False

    # Headers
    zip_filename = os.path.splitext(name)[0] + ".zip"
    handler.set_header("Content-Disposition", 'attachment; filename="%s"' % escape.url_escape(zip_filename))
    handler.set_header("Content-Type", "application/zip")

    # Prepare the zip file
    buffer = io.BytesIO()
    zipf = zipfile.ZipFile(buffer, mode="w", compression=zipfile.ZIP_DEFLATED)
    output_filename = os.path.splitext(name)[0] + resources["output_extension"]
    zipf.writestr(output_filename, cast_bytes(output, "utf-8"))
    for filename, data in output_files.items():
        zipf.writestr(os.path.basename(filename), data)
    zipf.close()

    handler.finish(buffer.getvalue())
    return True
コード例 #28
0
 def setUp(self):
     super(TestProjectHandlers, self).setUp()
     self.database = 'couch_test'
     self.project_id = '测试项目'
     self.url = "/api/v1/{0}/project/{1}".format(self.database, url_escape(self.project_id))
     self.json_header = {"Content-Type": "application/json"}
     self.type = {'type': 'project'}
コード例 #29
0
ファイル: store.py プロジェクト: angelapper/jupyterhub
 def render_auth_page(self, request, response, environ, scopes, client):
     """Auth page is a redirect to login page"""
     response.status_code = 302
     response.headers['Location'] = self.login_url + '?next={}'.format(
         url_escape(request.handler.request.path + '?' + request.handler.request.query)
     )
     return response
コード例 #30
0
    def test_max_kernels(self):
        """Number of kernels should be limited."""
        app = self.get_app()
        app.settings["kg_max_kernels"] = 1

        # Request a kernel
        response = yield self.http_client.fetch(self.get_url("/api/kernels"), method="POST", body="{}")
        self.assertEqual(response.code, 201)

        # Request another
        response2 = yield self.http_client.fetch(
            self.get_url("/api/kernels"), method="POST", body="{}", raise_error=False
        )
        self.assertEqual(response2.code, 402)

        # Shut down the kernel
        kernel = json_decode(response.body)
        response = yield self.http_client.fetch(
            self.get_url("/api/kernels/" + url_escape(kernel["id"])), method="DELETE"
        )
        self.assertEqual(response.code, 204)

        # Try again
        response = yield self.http_client.fetch(self.get_url("/api/kernels"), method="POST", body="{}")
        self.assertEqual(response.code, 201)
コード例 #31
0
    def test_saving_a_comment_is_stored(self):
        #submit a comment to /share_key/save_comment
        body = """This is a comment.

        A multi-line comment.&amp;

        That is all.&_xsrf=asdf
        """
        request = HTTPRequest(
            self.get_url('/p/%s/comment' % self.shf.share_key), 'POST',
            {'Cookie': '_xsrf=%s;sid=%s' % (self.xsrf, self.sid)},
            "body=%s&_xsrf=%s" % (url_escape(body), self.xsrf))
        self.http_client.fetch(request, self.stop)
        response = self.wait()

        comments = self.shf.comments()
        self.assertEqual(len(comments), 1)
        self.assertEqual(comments[0].body, body.strip())
コード例 #32
0
ファイル: server.py プロジェクト: mseyne/textadv
 def __init__(self, gamename, game, session, nolog=False):
     self.gamename = gamename
     self.game = game
     dirname = os.path.join(os.path.dirname(__file__), "logs")
     if not os.path.exists(dirname):
         os.mkdir(dirname)
     if nolog:
         logfile = None
         self.logfile_name = None
     else:
         self.logfile_name = os.path.abspath(
             os.path.join(dirname,
                          gamename + "_" + url_escape(session) + ".html"))
         logfile = open(self.logfile_name, "w")
     self.game_context = self.game.make_actorcontext_with_io(
         TornadoGameIO(logfile, frontispiece=session[0:8]))
     self.session = session
     threading.Thread.__init__(self)
コード例 #33
0
    def test_query_parsing(self):
        querys = [
            '',
            'query=',
            'query=hola',
            'query=' + url_escape('{}'),
            self.get_body('^', 1, 1),
            self.get_body('*'),
            '&%$(&%(&%$   +++////))',
        ]

        for query in querys:
            with self.subTest(query=query):
                response = yield self.send_query(query)
                self.assertIsNone(response['result'])

        response = yield self.send_f_query('+', 1, 1)
        self.assertIsNotNone(response['result'])
コード例 #34
0
 def client_fetch(*parts, headers={}, params={}, **kwargs):
     # Handle URL strings
     path = url_escape(url_path_join(*parts), plus=False)
     urlparts = urllib.parse.urlparse('ws://localhost:{}'.format(jp_http_port))
     urlparts = urlparts._replace(
         path=path,
         query=urllib.parse.urlencode(params)
     )
     url = urlparts.geturl()
     # Add auth keys to header
     headers.update(jp_auth_header)
     # Make request.
     req = tornado.httpclient.HTTPRequest(
         url,
         headers=jp_auth_header,
         connect_timeout=120
     )
     return tornado.websocket.websocket_connect(req)
コード例 #35
0
def showImage(show=None, which=None):
    media = None
    media_format = ('normal', 'thumb')[which in ('banner_thumb', 'poster_thumb', 'small')]

    try:
        if which[0:6] == 'banner':
            media = Banner(show, media_format)
        elif which[0:6] == 'fanart':
            media = FanArt(show, media_format)
        elif which[0:6] == 'poster':
            media = Poster(show, media_format)
        elif which[0:7] == 'network':
            media = Network(show, media_format)

        static_url = url_escape(media.get_media, False)
        return static_url
    except:
        pass
コード例 #36
0
    async def _connect(self, kernel_id, message_callback):
        # websocket is initialized before connection
        self.ws = None
        self.kernel_id = kernel_id
        ws_url = url_path_join(GatewayClient.instance().ws_url,
                               GatewayClient.instance().kernels_endpoint,
                               url_escape(kernel_id), 'channels')
        self.log.info('Connecting to {}'.format(ws_url))
        kwargs = {}
        kwargs = GatewayClient.instance().load_connection_args(**kwargs)

        request = HTTPRequest(ws_url, **kwargs)
        self.ws_future = websocket_connect(request)
        self.ws_future.add_done_callback(self._connection_done)

        loop = IOLoop.current()
        loop.add_future(self.ws_future,
                        lambda future: self._read_messages(message_callback))
コード例 #37
0
def get_temp_qrcode_url(event_id):
    access_token = yield get_access_token()
    url = wxconfig.temp_qrcode_url.format(access_token)
    param = {
        'expire_seconds': 2592000,
        'action_name': 'QR_SCENE',
        'action_info': {
            'scene': {
                'scene_id': event_id
            }
        }
    }
    http_client = AsyncHTTPClient()
    response = yield http_client.fetch(url, **{'method': 'POST',
                                               'body': json.dumps(param, ensure_ascii=False)})
    result = json.loads(response.body.decode())
    ticket = escape.url_escape(result['ticket'])
    return wxconfig.temp_qrcode_ticket_url.format(ticket)
コード例 #38
0
ファイル: pcs.py プロジェクト: jcteng/baiduAPIsUtils
    def uploadFile(self,
                   localPath,
                   targetPath,
                   datastream=None,
                   isOverWrite=False,
                   isCreateSuperFile=False):
        targetPath = url_escape(targetPath)

        if isOverWrite:
            ondup = 'overwrite'
        else:
            ondup = "newcopy"
        import os

        if isCreateSuperFile:
            appendURL = "&type=tmpfile"
        else:
            appendURL = ""

        if datastream == None:
            fp = open(localPath, "rb")
            datastream = fp.read()
            fp.close()

        md = hashlib.md5()
        md.update(datastream)
        md5sum = md.hexdigest()

        fname = os.path.basename(localPath)
        urlTemplate = "https://c.pcs.baidu.com/rest/2.0/pcs/file?method=upload&path=%s&access_token=%s&ondup=%s%s" % (
            targetPath, self.tokens["access_token"], ondup, appendURL)
        body, boundary = self.encode_baidu_formdata(datastream, fname)
        headers = {
            "Content-Type": 'multipart/form-data; boundary=%s' % boundary
        }
        resp = yield self.fetch(urlTemplate,
                                method="POST",
                                body=body,
                                headers=headers)
        jsonresp = json.loads(resp.body)
        if md5sum != jsonresp["md5"]:
            raise IOError("md5 check error", "in __file__")

        raise gen.Return(jsonresp)
コード例 #39
0
    def get(self, format, path):
        
        exporter = get_exporter(format, config=self.config, log=self.log)
        
        path = path.strip('/')
        model = self.contents_manager.get(path=path)
        name = model['name']
        if model['type'] != 'notebook':
            # not a notebook, redirect to files
            return FilesRedirectHandler.redirect_to_files(self, path)

        self.set_header('Last-Modified', model['last_modified'])

        try:
            output, resources = exporter.from_notebook_node(
                model['content'],
                resources={
                    "metadata": {
                        "name": name[:name.rfind('.')],
                        "modified_date": (model['last_modified']
                            .strftime(text.date_format))
                    },
                    "config_dir": self.application.settings['config_dir'],
                }
            )
        except Exception as e:
            self.log.exception("nbconvert failed: %s", e)
            raise web.HTTPError(500, "nbconvert failed: %s" % e)

        if respond_zip(self, name, output, resources):
            return

        # Force download if requested
        if self.get_argument('download', 'false').lower() == 'true':
            filename = os.path.splitext(name)[0] + resources['output_extension']
            self.set_header('Content-Disposition',
                               'attachment; filename="%s"' % escape.url_escape(filename))

        # MIME type
        if exporter.output_mimetype:
            self.set_header('Content-Type',
                            '%s; charset=utf-8' % exporter.output_mimetype)

        self.finish(output)
コード例 #40
0
    def post(self, *args, **kwargs):
        self.set_header('Content-Type', 'application/json')

        detection_id = ObjectId()

        app_log.info(
            "app=detection,function=detect,detection_id=%s,application_id=%s,session_id=%s,q=%s",
            detection_id, self.param_extractor.application_id(),
            self.param_extractor.session_id(), self.param_extractor.query())

        if False:
            url = "%smessage?v=%s&q=%s&msg_id=%s" % (
                WIT_URL, WIT_URL_VERSION,
                url_escape(self.param_extractor.query()), str(detection_id))
            r = HTTPRequest(url,
                            headers={"Authorization": "Bearer %s" % WIT_TOKEN})
            client = AsyncHTTPClient()
            client.fetch(r, callback=self.wit_call_back)
        else:
            date = datetime.now()
            outcomes = self.brute_detector.detect(self.param_extractor.query())
            self.data_response.insert(self.param_extractor.user_id(),
                                      self.param_extractor.application_id(),
                                      self.param_extractor.session_id(),
                                      detection_id,
                                      "brute",
                                      date,
                                      self.param_extractor.query(),
                                      outcomes=outcomes)

            self.set_status(202)
            self.set_header("Location", "/%s" % str(detection_id))
            self.set_header("_id", str(detection_id))
            self.finish()

            Worker(self.param_extractor.user_id(),
                   self.param_extractor.application_id(),
                   self.param_extractor.session_id(),
                   detection_id,
                   date,
                   self.param_extractor.query(),
                   self.param_extractor.skip_slack_log(),
                   detection_type="wit",
                   outcomes=outcomes).start()
コード例 #41
0
ファイル: handlers.py プロジェクト: zmackie/notebook
    def get(self, path, include_body=True):
        cm = self.contents_manager
        if cm.is_hidden(path):
            self.log.info("Refusing to serve hidden file, via 404 Error")
            raise web.HTTPError(404)

        path = path.strip('/')
        if '/' in path:
            _, name = path.rsplit('/', 1)
        else:
            name = path

        model = cm.get(path, type='file', content=include_body)

        if self.get_argument("download", False):
            self.set_header(
                'Content-Disposition',
                'attachment; filename="%s"' % escape.url_escape(name))

        # get mimetype from filename
        if name.endswith('.ipynb'):
            self.set_header('Content-Type', 'application/x-ipynb+json')
        else:
            cur_mime = mimetypes.guess_type(name)[0]
            if cur_mime == 'text/plain':
                self.set_header('Content-Type', 'text/plain; charset=UTF-8')
            elif cur_mime is not None:
                self.set_header('Content-Type', cur_mime)
            else:
                if model['format'] == 'base64':
                    self.set_header('Content-Type', 'application/octet-stream')
                else:
                    self.set_header('Content-Type',
                                    'text/plain; charset=UTF-8')

        if include_body:
            if model['format'] == 'base64':
                b64_bytes = model['content'].encode('ascii')
                self.write(decodebytes(b64_bytes))
            elif model['format'] == 'json':
                self.write(json.dumps(model['content']))
            else:
                self.write(model['content'])
            self.flush()
コード例 #42
0
    def test_adding_video_makes_it_show_up_in_friends_shake(self):
        user2 = User(name='user2',
                     email='*****@*****.**',
                     email_confirmed=1,
                     is_paid=1)
        user2.set_password('asdfasdf')
        user2.save()
        user2.subscribe(self.user.shake())

        url = 'https://vimeo.com/20379529'
        request = HTTPRequest(
            self.get_url('/tools/save-video'), 'POST',
            {"Cookie": "sid=%s;_xsrf=%s" % (self.sid, self.xsrf)},
            "url=%s&_xsrf=%s" % (url_escape(url), self.xsrf))
        self.http_client.fetch(request, self.stop)
        response = self.wait()
        sfs = Sharedfile.from_subscriptions(user2.id)
        self.assertTrue(len(sfs) > 0)
        self.assertEqual(sfs[0].name, url)
コード例 #43
0
    async def post(self) -> None:
        lexer = self.get_body_argument("lexer")
        raw = self.get_body_argument("code", strip=False)
        expiry = self.get_body_argument("expiry")
        filename = self.get_body_argument("filename", None)

        if not raw or not raw.strip():
            log.info("APINew.post: a paste was submitted without content")
            raise tornado.web.HTTPError(400)

        if lexer not in utility.list_languages():
            log.info("APINew.post: a paste was submitted with an invalid lexer")
            raise tornado.web.HTTPError(400)

        if expiry not in configuration.expiries:
            log.info(
                "APINew.post: a paste was submitted with an invalid expiry"
            )
            raise tornado.web.HTTPError(400)

        paste = database.Paste(
            utility.slug_create(),
            configuration.expiries[expiry],
            "deprecated-api",
        )
        paste.files.append(database.File(paste.slug, raw, lexer, filename))

        with database.session() as session:
            session.add(paste)
            session.commit()

            req_url = self.request.full_url()
            location = paste.slug
            if filename:
                location += "#" + url_escape(filename)
            self.write(
                {
                    "paste_id": paste.slug,
                    "removal_id": paste.removal,
                    "paste_url": urljoin(req_url, f"/{location}"),
                    "raw_url": urljoin(req_url, f"/raw/{paste.files[0].slug}"),
                }
            )
コード例 #44
0
    def test_max_kernels_per_user(self):
        """
        Number of kernels should be limited per user.
        """

        self.get_app()
        self.app.max_kernels_per_user = 1

        # Request a kernel for bob
        bob_response = yield self.http_client.fetch(
            self.get_url('/api/kernels'),
            method='POST',
            body='{"env": {"KERNEL_USERNAME": "******"} }')
        self.assertEqual(bob_response.code, 201)

        # Request a kernel for alice
        alice_response = yield self.http_client.fetch(
            self.get_url('/api/kernels'),
            method='POST',
            body='{"env": {"KERNEL_USERNAME": "******"} }')
        self.assertEqual(alice_response.code, 201)

        # Request another for alice - 403 expected
        failed_response = yield self.http_client.fetch(
            self.get_url('/api/kernels'),
            method='POST',
            body='{"env": {"KERNEL_USERNAME": "******"} }',
            raise_error=False)
        self.assertEqual(failed_response.code, 403)

        # Shut down the kernel for alice
        kernel = json_decode(alice_response.body)
        response = yield self.http_client.fetch(
            self.get_url('/api/kernels/' + url_escape(kernel['id'])),
            method='DELETE')
        self.assertEqual(response.code, 204)

        # Try again for alice - expect success
        alice_response = yield self.http_client.fetch(
            self.get_url('/api/kernels'),
            method='POST',
            body='{"env": {"KERNEL_USERNAME": "******"} }')
        self.assertEqual(alice_response.code, 201)
コード例 #45
0
def bundle(handler, model):
    '''
    Bundles a notebook as a static web application on this Jupyter Notebook
    server and redirects the requestor there.
    '''
    try:
        # Noteook implementation passes ContentManager models. This bundler
        # only works with local files anyway.
        abs_nb_path = os.path.join(
            handler.settings['contents_manager'].root_dir, model['path'])
    except KeyError:
        # Original jupyter_cms implementation passes absolute path on disk
        abs_nb_path = model

    # Get name of notebook from filename
    notebook_basename = os.path.basename(abs_nb_path)
    notebook_name = os.path.splitext(notebook_basename)[0]

    # Always put the app in a local_dashboards directory
    output_dir = pjoin(handler.notebook_dir, 'local_dashboards', notebook_name)

    # Clean up bundle dir if it exists
    shutil.rmtree(output_dir, True)
    os.makedirs(output_dir)

    # Generate the index.html file
    bundle_index(output_dir, abs_nb_path, DEFAULT_TEMPLATE_PATH)

    # Include frontend files referenced via the bundler tools mechanism
    bundle_file_references(output_dir, abs_nb_path, handler.tools)

    # Include static web assets (e.g., Thebe)
    bundle_web_static(output_dir)

    # Copy declarative widgets if they were used
    bundle_declarative_widgets(output_dir, abs_nb_path)

    # Redirect the user to the new local app
    bundle_url_path = url_path_join(handler.settings['base_url'], 'files',
                                    'local_dashboards',
                                    escape.url_escape(notebook_name,
                                                      False), 'index.html')
    handler.redirect(bundle_url_path)
コード例 #46
0
 def client_fetch(*parts, headers=None, params=None, **kwargs):
     if not headers:
         headers = {}
     if not params:
         params = {}
     # Handle URL strings
     path_url = url_escape(url_path_join(*parts), plus=False)
     base_path_url = url_path_join(jp_base_url, path_url)
     urlparts = urllib.parse.urlparse(f"ws://localhost:{jp_http_port}")
     urlparts = urlparts._replace(path=base_path_url,
                                  query=urllib.parse.urlencode(params))
     url = urlparts.geturl()
     # Add auth keys to header
     headers.update(jp_auth_header)
     # Make request.
     req = tornado.httpclient.HTTPRequest(url,
                                          headers=headers,
                                          connect_timeout=120)
     return tornado.websocket.websocket_connect(req)
コード例 #47
0
    def _render(self, login_error=None, username=None):
        landing_url = os.getenv("LANDING_URL")
        crisp_website_id = os.getenv("CRISP_WEBSITE_ID")
        auth_url = os.getenv("AUTH_URL", "http://127.0.0.1:5000")

        return self.render_template(
            "native-login.html",
            next=url_escape(self.get_argument("next", default="/hub")),
            username=username,
            login_error=login_error,
            custom_html=self.authenticator.custom_html,
            login_url=self.settings["login_url"],
            landing_url=landing_url,
            crisp_website_id=crisp_website_id,
            auth_url=auth_url,
            authenticator_login_url=url_concat(
                self.authenticator.login_url(self.hub.base_url),
                {"next": self.get_argument("next", "")},
            ),
        )
コード例 #48
0
ファイル: movievndailyscom.py プロジェクト: santatic/getmovie
	def search(self, text):
		movies 	= []
		try:
			text 	= escape.url_escape(text)
			text 	= "http://movie.vndailys.com/search.php?q=%s&limit=20" % text
			data 	= yield http_client(text, c_try=5, c_delay=self.delay)
			data 	= data.split('</a></li>',1)[1].rsplit('</a></li>',1)[0].split('</a></li>')
			movies 	= []
			for m in data:
				link = m.split('<a href="',1)[1].split('"',1)[0]
				title = ' - '.join(m.split('<strong>',1)[1].split('<br ',1)[0].split('</strong><br>'))
				image = 'http://phimtv.vn/' + m.split('src="',1)[1].split('"',1)[0]
				movies.append({
						"link": link,
						"title": title,
						"image": image
					})
		except Exception as e:
			traceback.print_exc(file=sys.stdout)
		return movies
コード例 #49
0
 def _connect(self, kernel_id):
     ws_url = url_path_join(KG_URL.replace('http', 'ws'), '/api/kernels',
                            url_escape(kernel_id), 'channels')
     self.log.info('Connecting to {}'.format(ws_url))
     parameters = {
         "headers": KG_HEADERS,
         "validate_cert": VALIDATE_KG_CERT,
         "auth_username": KG_HTTP_USER,
         "auth_password": KG_HTTP_PASS,
         "connect_timeout": KG_CONNECT_TIMEOUT,
         "request_timeout": KG_REQUEST_TIMEOUT
     }
     if KG_CLIENT_KEY:
         parameters["client_key"] = KG_CLIENT_KEY
         parameters["client_cert"] = KG_CLIENT_CERT
         if KG_CLIENT_CA:
             parameters["ca_certs"] = KG_CLIENT_CA
     request = HTTPRequest(ws_url, **parameters)
     self.ws_future = websocket_connect(request)
     self.ws = yield self.ws_future
コード例 #50
0
ファイル: common.py プロジェクト: baifengbai/doc2docx
def force_browser_download_content(handler, fname):
    fname = filter_unsafe_http_header_value(fname)
    if not fname:
        fname = u'未命名'
    agent = httpagentparser.detect(
        handler.request.headers.get('User-Agent', u''))
    browser = agent.get('browser', None) if agent else None
    header_set = False
    escaped_fname = url_escape(fname, False)
    if browser:
        if browser.get('name', u'') == 'Microsoft Internet Explorer' and\
                browser.get('version', u'') in ('7.0', '8.0'):
            handler.set_header('Content-Disposition',
                               'attachment;filename={}'.format(escaped_fname))
            header_set = True
    if not header_set:
        handler.set_header(
            'Content-Disposition',
            'attachment;filename="{}";filename*=UTF-8\'\'{}'.format(
                fname.encode('utf-8'), escaped_fname))
コード例 #51
0
    def get(self):
        content = self.get_query_argument('chl', strip=False)

        url = 'https://chart.googleapis.com/chart?cht=qr&chs=%dx%d&chl=%s&chld=|0'\
              % (200, 200, escape.url_escape('ss://' + content, plus=False))

        request = HTTPRequest(url)

        if options.debug:
            logging.debug("qrcode url: " + url)
            request.proxy_host = '127.0.0.1'
            request.proxy_port = 8123

            client = curl_httpclient.CurlAsyncHTTPClient()
        else:
            client = AsyncHTTPClient()

        response = yield client.fetch(request)

        self.write_png(response.body)
コード例 #52
0
ファイル: base.py プロジェクト: Sage-Bionetworks/nbviewer
    def redirect(self, url, *args, **kwargs):
        purl = urlparse(url)

        eurl = urlunparse((
            purl.scheme,
            purl.netloc,
            "/".join([
                url_escape(url_unescape(p), plus=False)
                for p in purl.path.split("/")
            ]),
            purl.params,
            purl.query,
            purl.fragment
        ))

        return super(BaseHandler, self).redirect(
            eurl,
            *args,
            **kwargs
        )
コード例 #53
0
async def connect(address, kernel_id):
    base_url = 'http://' + address
    base_ws_url = 'ws://' + address

    client = AsyncHTTPClient()
    if not kernel_id:
        response = await client.fetch('{}/api/kernels'.format(base_url),
                                      method='POST',
                                      auth_username='******',
                                      auth_password='******',
                                      body=json_encode({'name': 'python'}))
        kernel = json_decode(response.body)
        kernel_id = kernel['id']

    ws_req = HTTPRequest(url='{}/api/kernels/{}/channels'.format(
        base_ws_url, url_escape(kernel_id)),
                         auth_username='******',
                         auth_password='******')
    ws = await websocket_connect(ws_req)
    return ws, kernel_id
コード例 #54
0
    async def start_kernel(self, **kwargs):
        """Starts a kernel via HTTP in an asynchronous manner.

        Parameters
        ----------
        `**kwargs` : optional
             keyword arguments that are passed down to build the kernel_cmd
             and launching the kernel (e.g. Popen kwargs).
        """
        kernel_id = kwargs.get('kernel_id')

        if kernel_id is None:
            kernel_name = kwargs.get('kernel_name', 'python3')
            self.log.debug("Request new kernel at: %s" % self.kernels_url)

            # Let KERNEL_USERNAME take precedent over http_user config option.
            if os.environ.get('KERNEL_USERNAME') is None and GatewayClient.instance().http_user:
                os.environ['KERNEL_USERNAME'] = GatewayClient.instance().http_user

            kernel_env = {k: v for (k, v) in dict(os.environ).items() if k.startswith('KERNEL_') or
                          k in GatewayClient.instance().env_whitelist.split(",")}

            # Add any env entries in this request
            kernel_env.update(kwargs.get('env', {}))

            # Convey the full path to where this notebook file is located.
            if kwargs.get('cwd') is not None and kernel_env.get('KERNEL_WORKING_DIR') is None:
                kernel_env['KERNEL_WORKING_DIR'] = kwargs['cwd']

            json_body = json_encode({'name': kernel_name, 'env': kernel_env})

            response = await gateway_request(self.kernels_url, method='POST', body=json_body)
            self.kernel = json_decode(response.body)
            self.kernel_id = self.kernel['id']
            self.log.info("GatewayKernelManager started kernel: {}, args: {}".format(self.kernel_id, kwargs))
        else:
            self.kernel_id = kernel_id
            self.kernel = await self.refresh_model()
            self.log.info("GatewayKernelManager using existing kernel: {}".format(self.kernel_id))

        self.kernel_url = url_path_join(self.kernels_url, url_escape(str(self.kernel_id)))
コード例 #55
0
    def post(self):
        ds_name = self.get_argument('ds_name')
        ds_kind = self.get_argument('ds_kind')
        description = self.get_argument('desc')

        resample = (self.get_argument('lb', ''), self.get_argument('ub', ''),
                    self.get_argument('step', ''))
        if not any(resample):
            resample = None

        if ds_kind not in DATASETS:
            self.visible_error(400, 'Invalid dataset kind.',
                               'Invalid ds_kind: %r', ds_kind)
            return

        if ds_name in DATASETS[ds_kind]:
            self.visible_error(403, 'Dataset already exists.',
                               'ds import would clobber existing: %s [%s]',
                               ds_name, ds_kind)
            return

        if not self.request.files or 'spectra' not in self.request.files:
            self.visible_error(400, 'No spectrum data uploaded.')
            return

        meta_file, = self.request.files.get('metadata', [None])
        spectra_file, = self.request.files['spectra']
        err = yield gen.Task(_async_ds_upload, meta_file, spectra_file,
                             ds_name, ds_kind, resample, description)
        if err:
            self.visible_error(*err)
            return

        # Return a link to the new dataset to signal the upload succeeded.
        self.write('/explorer?ds_kind=%s&ds_name=%s' %
                   (ds_kind, url_escape(ds_name, plus=False)))

        # Kick off a background thread to save this new dataset to disk.
        t = Thread(target=_save_ds, args=(ds_kind, ds_name))
        t.daemon = True
        t.start()
コード例 #56
0
ファイル: ebi_handlers.py プロジェクト: charles-cowart/qiita
    def post(self, preprocessed_data_id):
        user = self.current_user
        # make sure user is admin and can therefore actually submit to EBI
        if user.level != 'admin':
            raise HTTPError(403,
                            reason="User %s cannot submit to EBI!" % user.id)
        submission_type = self.get_argument('submission_type')

        if submission_type not in ['ADD', 'MODIFY']:
            raise HTTPError(403,
                            reason="User: %s, %s is not a recognized "
                            "submission type" % (user.id, submission_type))

        study = Artifact(preprocessed_data_id).study
        state = study.ebi_submission_status
        if state == 'submitting':
            message = "Cannot resubmit! Current state is: %s" % state
            self.display_template(preprocessed_data_id, message, 'danger')
        else:
            qiita_plugin = Software.from_name_and_version('Qiita', 'alpha')
            cmd = qiita_plugin.get_command('submit_to_EBI')
            params = Parameters.load(cmd,
                                     values_dict={
                                         'artifact': preprocessed_data_id,
                                         'submission_type': submission_type
                                     })
            job = ProcessingJob.create(user, params, True)

            r_client.set('ebi_submission_%s' % preprocessed_data_id,
                         dumps({
                             'job_id': job.id,
                             'is_qiita_job': True
                         }))
            job.submit()

            level = 'success'
            message = 'EBI submission started. Job id: %s' % job.id

            self.redirect("%s/study/description/%d?level=%s&message=%s" %
                          (qiita_config.portal_dir, study.id, level,
                           url_escape(message)))
コード例 #57
0
ファイル: handlers.py プロジェクト: tuhuayuan/tracer
    def post_add_tracer(self):
        """新建一个追踪对象
        1、生成二维码 2、写入数据库 3、创建静态页面
        """
        title = self.get_body_argument("tracer_title", default="")
        content = self.get_body_argument("tracer_content", default="")
        tracer_id = self.get_body_argument("tracer_id",
                                           default=Tracer.gen_id(12))
        tracer_url = self.get_body_argument("tracer_url", default="") + \
            "/" + tracer_id + ".html"
        qr_url = ""

        client = AsyncHTTPClient()
        req = HTTPRequest(
            url="http://" + self.request.host + self.reverse_url("QRViewer") +
            "?token=" + options.qr_token,
            method="POST",
            body="key=" + tracer_id + "&value=" + tracer_url,
        )
        resp = yield client.fetch(req)
        if resp.code == 200:
            ret = json.load(StringIO(resp.body))
            print(ret)
            qr_url = ret["url"]

        tracer = Tracer(
            id=tracer_id,
            title=title,
            content=content,
            clicked=0,
            posted=int(time.time()),
            qr=qr_url,
            url=tracer_url,
        )
        self._gen_tracer_page(tracer)
        self.dbsession.merge(tracer)
        self.dbsession.commit()

        self.redirect(
            self.reverse_url("TracerShower", tracer_id) + "?next=" +
            url_escape(self.reverse_url("TracerManager", "list", 0)))
コード例 #58
0
    def _gen_test_tag_resp(cls, request):
        response = {}

        if 'tests_tag' in Settings and Settings['tests_tag']['tag'] in request['tags']:
            response['tag'] = Settings['tests_tag']['tag']
            try:
                api_url = Settings['tests_tag']['tag_api_endpoint'].replace('%SHA%', request['revision'])
                api_body = Settings['tests_tag']['tag_api_body'].replace('%SHA%', request['revision'])
                api_resp = urllib2.urlopen(api_url, api_body)
                response['tag'] = xhtml_escape(json.loads(api_resp.read())['tag'])
            except Exception as e:
                response['tag'] += ": ERROR connecting to server"
                logging.error(e)

            response['url'] = ''
            if 'url_api_endpoint' in Settings['tests_tag']:
                try:
                    result_api_url = Settings['tests_tag']['url_api_endpoint'].replace('%SHA%', request['revision'])
                    result_api_url = result_api_url.replace('%BRANCH%', request['branch'])
                    result_api_body = Settings['tests_tag']['url_api_body'].replace('%SHA%', request['revision'])
                    result_api_body = result_api_body.replace('%BRANCH%', request['branch'])
                    resp = urllib2.urlopen(result_api_url, result_api_body)
                    result_id = url_escape(json.loads(resp.read())['id'])
                    if result_id != '':
                        response['url'] = Settings['tests_tag']['url_tmpl'].replace(
                            '%ID%',
                            result_id
                        ).replace(
                            '%SHA%',
                            request['revision']
                        )
                        response['url'] = response['url'].replace('%BRANCH%', request['branch'])
                except Exception as e:
                    logging.warning(e)
                    logging.warning(
                        "Couldn't load results for results test URL from %s with body %s" % (
                            Settings['tests_tag']['url_api_endpoint'].replace('%SHA%', request['revision']),
                            Settings['tests_tag']['url_api_body'].replace('%SHA%', request['revision'])
                        )
                    )
        return response
コード例 #59
0
 def _view(self, url, **kwargs):
     body = kwargs.get('body', {})
     options = []
     if kwargs:
         for key, value in kwargs.items():
             if key == 'body':
                 continue
             if key == 'keys':
                 body.update({'keys': value})
             else:
                 value = url_escape(value if key in (
                     'startkey_docid', 'endkey_docid',
                     'stale') else json_encode(value))
                 options.append('='.join([key, value]))
     if options:
         url = '{0}?{1}'.format(url, '&'.join(options))
     if body:
         r = yield self._http_post(url, json_encode(body))
     else:
         r = yield self._http_get(url)
     raise gen.Return(r)
コード例 #60
0
    def spawn_kernel(self, kernel_body='{}'):
        '''
        Code to spawn a kernel and return a websocket connection to it.
        '''
        # Request a kernel
        response = yield self.http_client.fetch(
            self.get_url('/api/kernels'),
            method='POST',
            body=kernel_body
        )
        self.assertEqual(response.code, 201)

        # Connect to the kernel via websocket
        kernel = json_decode(response.body)
        ws_url = 'ws://localhost:{}/api/kernels/{}/channels'.format(
            self.get_http_port(),
            url_escape(kernel['id'])
        )

        ws = yield websocket_connect(ws_url)
        raise Return(ws)