"(&(objectClass=inetOrgPerson)(|(sipAuthenticationUser=%s)(telephoneNumber=%s)(homePhone=%s)(mobile=%s)))" \
% (number, number, number, number))
- @tornado.gen.coroutine
- def check_spam(self, uid, email, address):
+ async def check_spam(self, uid, email, address):
sfs = StopForumSpam(self.backend, uid, email, address)
# Get spam score
- score = yield sfs.check()
+ score = await sfs.check()
return score >= 50
def init(self, uid, email, address):
self.uid, self.email, self.address = uid, email, address
- @tornado.gen.coroutine
- def send_request(self, **kwargs):
+ async def send_request(self, **kwargs):
arguments = {
"json" : "1",
}
request.body = urllib.parse.urlencode(arguments)
# Send the request
- response = yield self.backend.http_client.fetch(request)
+ response = await self.backend.http_client.fetch(request)
# Decode the JSON response
return json.loads(response.body.decode())
- @tornado.gen.coroutine
- def check_address(self):
- response = yield self.send_request(ip=self.address)
+ async def check_address(self):
+ response = await self.send_request(ip=self.address)
try:
confidence = response["ip"]["confidence"]
return confidence
- @tornado.gen.coroutine
- def check_username(self):
- response = yield self.send_request(username=self.uid)
+ async def check_username(self):
+ response = await self.send_request(username=self.uid)
try:
confidence = response["username"]["confidence"]
return confidence
- @tornado.gen.coroutine
- def check_email(self):
- response = yield self.send_request(email=self.email)
+ async def check_email(self):
+ response = await self.send_request(email=self.email)
try:
confidence = response["email"]["confidence"]
return confidence
- @tornado.gen.coroutine
- def check(self, threshold=95):
+ async def check(self, threshold=95):
"""
This function tries to detect if we have a spammer.
address and username and if those are on the database, we
will send the email address as well.
"""
- confidences = yield [self.check_address(), self.check_username()]
+ confidences = [await self.check_address(), await self.check_username()]
if any((c < threshold for c in confidences)):
- confidences += yield [self.check_email()]
+ confidences.append(await self.check_email())
# Build a score based on the lowest confidence
return 100 - min(confidences)
import configparser
import io
-import tornado.gen
import tornado.httpclient
from . import accounts
self.db = database.Connection(**credentials)
- @tornado.gen.coroutine
- def run_task(self, task, *args, **kwargs):
+ async def run_task(self, task, *args, **kwargs):
tasks = {
"check-mirrors" : self.mirrors.check_all,
"check-spam" : self.accounts.check_spam,
raise ValueError("Unknown task: %s" % task)
# Run the task
- r = yield func(*args, **kwargs)
+ r = await func(*args, **kwargs)
# If any error code has been returned,
# we will end the program
def tweets(self):
return tweets.Tweets(self)
- @tornado.gen.coroutine
- def cleanup(self):
+ async def cleanup(self):
# Cleanup message queue
with self.db.transaction():
self.messages.queue.cleanup()
import markdown.preprocessors
import re
import textile
-import tornado.gen
import unicodedata
from . import misc
for row in res:
yield row.year
- @tornado.gen.coroutine
- def update_feeds(self):
+ async def update_feeds(self):
"""
Updates all enabled feeds
"""
# Overwrite Channel
self.channel = pycares.Channel(sock_state_cb=self._sock_state_cb, **kwargs)
- @tornado.gen.coroutine
- def query(self, name, type=pycares.QUERY_TYPE_A):
+ async def query(self, name, type=pycares.QUERY_TYPE_A):
# Create a new Future
fut = tornado.gen.Future()
self.channel.query(name, type, lambda result, error: fut.set_result((result, error)))
# Wait for the response
- result, error = yield fut
+ result, error = await fut
# Handle any errors
if error:
def get_country_name(self, code):
return countries.get_name(code)
- @tornado.gen.coroutine
- def test_blacklist(self, address):
+ async def test_blacklist(self, address):
address = self.lookup(address)
# Determne blacklist status
- status = yield address.is_blacklisted()
+ status = await address.is_blacklisted()
print("Blacklist status for %s: %s" % (address, status))
return ".".join(octets)
- @tornado.gen.coroutine
- def _resolve_blacklist(self, blacklist):
+ async def _resolve_blacklist(self, blacklist):
return_code = None
# Get resource record name
# Run query
try:
- res = yield self.backend.geoip.resolver.query(rr, type=type)
+ res = await self.backend.geoip.resolver.query(rr, type=type)
except IOError as e:
logging.warning(e)
break
# If the IP address is on a blacklist, we will try to fetch the TXT record
- reason = yield self.backend.geoip.resolver.query(rr, type=pycares.QUERY_TYPE_TXT)
+ reason = await self.backend.geoip.resolver.query(rr, type=pycares.QUERY_TYPE_TXT)
# Log result
logging.debug("%s is blacklisted on %s: %s" % (self, blacklist, reason or "N/A"))
# Blocked, but no reason
return return_code, None
- @tornado.gen.coroutine
- def get_blacklists(self):
- blacklists = yield { bl : self._resolve_blacklist(bl) for bl in BLACKLISTS }
+ async def get_blacklists(self):
+ blacklists = { bl : self._resolve_blacklist(bl) for bl in BLACKLISTS }
return blacklists
- @tornado.gen.coroutine
- def is_blacklisted(self):
+ async def is_blacklisted(self):
logging.debug("Checking if %s is blacklisted..." % self)
# Perform checks
- blacklists = yield { bl : self._resolve_blacklist(bl) for bl in BLOCKLISTS }
+ blacklists = { bl : self._resolve_blacklist(bl) for bl in BLOCKLISTS }
# If we are blacklisted on one list, this one is screwed
for bl in blacklists:
- code, message = blacklists[bl]
+ code, message = await blacklists[bl]
logging.debug("Response from %s is: %s (%s)" % (bl, code, message))
import email.utils
import logging
import subprocess
-import tornado.gen
import tornado.template
from . import accounts
WHERE time_sent IS NULL \
ORDER BY priority DESC, time_created ASC")
- @tornado.gen.coroutine
- def send_all(self):
+ async def send_all(self):
# Sends all messages
for message in self.messages:
self._sendmail(message)
import socket
import time
import ssl
-import tornado.gen
import tornado.httpclient
import tornado.iostream
import tornado.netutil
return iter(mirrors)
- @tornado.gen.coroutine
- def check_all(self):
+ async def check_all(self):
for mirror in self:
with self.db.transaction():
- yield mirror.check()
+ await mirror.check()
def get_for_download(self, filename, country_code=None):
# Try to find a good mirror for this country first
def disabled(self):
return not self.enabled
- @tornado.gen.coroutine
- def check(self):
+ async def check(self):
logging.debug("Running check for mirror %s" % self.hostname)
self.db.execute("UPDATE mirrors SET address = %s WHERE id = %s",
self.address, self.id)
- success = yield self.check_timestamp()
-
+ success = await self.check_timestamp()
if success:
- yield self.check_filelist()
+ await self.check_filelist()
def check_state(self, last_update):
logging.debug("Checking state of mirror %s" % self.id)
self.set_state("UP")
- @tornado.gen.coroutine
- def check_timestamp(self):
+ async def check_timestamp(self):
http = tornado.httpclient.AsyncHTTPClient()
try:
- response = yield http.fetch(self.url + ".timestamp",
+ response = await http.fetch(self.url + ".timestamp",
headers={ "Pragma" : "no-cache" })
except tornado.httpclient.HTTPError as e:
logging.error("Error getting timestamp from %s: %s" % (self.hostname, e))
return True
- @tornado.gen.coroutine
- def check_filelist(self):
+ async def check_filelist(self):
# XXX need to remove data from disabled mirrors
if not self.enabled:
return
http = tornado.httpclient.AsyncHTTPClient()
try:
- response = yield http.fetch(self.url + ".filelist",
+ response = await http.fetch(self.url + ".filelist",
headers={ "Pragma" : "no-cache" })
except tornado.httpclient.HTTPError as e:
logging.error("Error getting filelist from %s: %s" % (self.hostname, e))
import logging
import os
import re
-import tornado.gen
import urllib.parse
import yabencode
return file
- @tornado.gen.coroutine
- def scan_files(self, basepath="/pub/mirror"):
+ async def scan_files(self, basepath="/pub/mirror"):
for release in self:
logging.debug("Scanning %s..." % release)
import datetime
import logging
-import tornado.gen
import twython
from .misc import Object
class Tweets(Object):
- @tornado.gen.coroutine
- def tweet(self):
+ async def tweet(self):
"""
Sends a random promotional tweet
"""
import logging
import os.path
import re
-import tornado.gen
import urllib.parse
from . import misc
import hmac
import json
import tornado.httpclient
-import tornado.gen
import urllib.parse
from .misc import Object
return h.hexdigest()
- @tornado.gen.coroutine
- def send_request(self, path, **kwargs):
+ async def send_request(self, path, **kwargs):
url = urllib.parse.urljoin(self.url, path)
# Query arguments are all keyword arguments
)
# Send the request
- response = yield self.backend.http_client.fetch(request)
+ response = await self.backend.http_client.fetch(request)
# Decode the JSON response
- d = json.loads(response.body.decode())
-
- raise tornado.gen.Return(d)
+ return json.loads(response.body.decode())
#!@PYTHON@
import sys
-import tornado.gen
import tornado.ioloop
import tornado.options
arguments asynchronically and exits the program in
case on a non-zero exit code
"""
- @tornado.gen.coroutine
- def task():
- yield self.backend.run_task(name, *args, **kwargs)
+ async def task():
+ await self.backend.run_task(name, *args, **kwargs)
return self.ioloop.run_sync(task)
self.render("auth/register.html")
- @tornado.gen.coroutine
@base.ratelimit(minutes=24*60, requests=5)
- def post(self):
+ async def post(self):
uid = self.get_argument("uid")
email = self.get_argument("email")
last_name = self.get_argument("last_name")
# Check if this is a spam account
- is_spam = yield self.backend.accounts.check_spam(uid, email,
+ is_spam = await self.backend.accounts.check_spam(uid, email,
address=self.get_remote_ip())
if is_spam:
from .. import util
def blacklisted(method):
- @tornado.gen.coroutine
@functools.wraps(method)
- def wrapper(self, *args, **kwargs):
+ async def wrapper(self, *args, **kwargs):
# Check if remote is blacklisted
- is_blacklisted = yield self.remote.is_blacklisted()
+ is_blacklisted = await self.remote.is_blacklisted()
# If so, redirect to the blocked page
if is_blacklisted:
#!/usr/bin/python3
import iso3166
-import tornado.gen
import tornado.web
from . import base
country=country, first_name=first_name, last_name=last_name,
amount=amount, currency=currency, frequency=frequency)
- @tornado.gen.coroutine
@base.ratelimit(minutes=24*60, requests=5)
- def post(self):
+ async def post(self):
amount = self.get_argument("amount")
currency = self.get_argument("currency", "EUR")
frequency = self.get_argument("frequency")
# Send request to Zeiterfassung
try:
- response = yield self.backend.zeiterfassung.send_request(
+ response = await self.backend.zeiterfassung.send_request(
"/api/v1/donations/create/ipfire-project", **args)
except Exception:
#!/usr/bin/python
import logging
-import tornado.gen
import tornado.web
from . import base
class LookupHandler(base.BaseHandler):
- @tornado.gen.coroutine
- def get(self, address):
+ async def get(self, address):
peer = self.geoip.get_all(address)
if peer:
peer["country_name"] = self.geoip.get_country_name(peer.country)
address = self.geoip.lookup(address)
# Lookup blacklists
- is_blacklisted = yield address.is_blacklisted()
+ is_blacklisted = await address.is_blacklisted()
self.render("location/lookup.html",
address=address, is_blacklisted=is_blacklisted, peer=peer)
class BlacklistsHandler(base.BaseHandler):
- @tornado.gen.coroutine
- def get(self, address):
+ async def get(self, address):
peer = self.geoip.get_all(address)
# Lookup address
address = self.geoip.lookup(address)
# Lookup blacklists
- blacklists = yield address.get_blacklists()
+ blacklists = await address.get_blacklists()
self.render("location/blacklists.html",
address=address, blacklists=blacklists)
import email.mime.text
import logging
-import tornado.gen
import tornado.process
from . import base
# Makes sure that we call blacklist for everything
pass
- @tornado.gen.coroutine
@base.ratelimit(minutes=15, requests=5)
def post(self):
address = self.get_argument("email")
projects / ipfire.org.git / commitdiff
