|
|
import logging
|
|
|
import asyncio
|
|
|
import re
|
|
|
import urllib.parse
|
|
|
from pysitemap.format_processors.xml import XMLWriter
|
|
|
from pysitemap.format_processors.text import TextWriter
|
|
|
import aiohttp
|
|
|
|
|
|
|
|
|
class Crawler:
|
|
|
|
|
|
format_processors = {
|
|
|
'xml': XMLWriter,
|
|
|
'txt': TextWriter
|
|
|
}
|
|
|
|
|
|
def __init__(self, rooturl, out_file, out_format='xml', maxtasks=10, exclude_urls=[], exclude_imgs=[],
|
|
|
verifyssl=True, headers=None, timezone_offset=0, changefreq=None, priorities=None,
|
|
|
todo_queue_backend=set, done_backend=dict):
|
|
|
"""
|
|
|
Crawler constructor
|
|
|
:param rooturl: root url of site
|
|
|
:type rooturl: str
|
|
|
:param out_file: file to save sitemap result
|
|
|
:type out_file: str
|
|
|
:param out_format: sitemap type [xml | txt]. Default xml
|
|
|
:type out_format: str
|
|
|
:param maxtasks: maximum count of tasks. Default 10
|
|
|
:type maxtasks: int
|
|
|
:param exclude_urls: excludable url paths relative to root url
|
|
|
:type exclude_urls: list
|
|
|
:param exclude_imgs: excludable img url paths relative to root url
|
|
|
:type exclude_imgs: list
|
|
|
:param verifyssl: verify website certificate?
|
|
|
:type verifyssl: boolean
|
|
|
:param timezone_offset: timezone offset for lastmod tags
|
|
|
:type timezone_offset: int
|
|
|
:param changefreq: dictionary, where key is site sub url regex, and value is changefreq
|
|
|
:type changefreq: dict
|
|
|
:param priorities: dictionary, where key is site sub url regex, and value is priority float
|
|
|
:type priorities: dict
|
|
|
"""
|
|
|
self.rooturl = rooturl
|
|
|
self.exclude_urls = exclude_urls
|
|
|
self.exclude_imgs = exclude_imgs
|
|
|
self.todo_queue = todo_queue_backend()
|
|
|
self.busy = set()
|
|
|
self.done = done_backend()
|
|
|
self.tasks = set()
|
|
|
self.sem = asyncio.Semaphore(maxtasks)
|
|
|
self.timezone_offset = timezone_offset
|
|
|
self.changefreq = changefreq
|
|
|
self.priorities = priorities
|
|
|
|
|
|
# connector stores cookies between requests and uses connection pool
|
|
|
self.session = aiohttp.ClientSession(
|
|
|
headers=headers,
|
|
|
connector=aiohttp.TCPConnector(verify_ssl=verifyssl)
|
|
|
)
|
|
|
self.writer = self.format_processors.get(out_format)(out_file)
|
|
|
|
|
|
async def run(self):
|
|
|
"""
|
|
|
Main function to start parsing site
|
|
|
:return:
|
|
|
"""
|
|
|
t = asyncio.ensure_future(self.addurls([(self.rooturl, '')]))
|
|
|
await asyncio.sleep(1)
|
|
|
while self.busy:
|
|
|
await asyncio.sleep(1)
|
|
|
|
|
|
await t
|
|
|
await self.session.close()
|
|
|
await self.writer.write([(key, value) for key, value in self.done.items() if key and value], self.timezone_offset)
|
|
|
|
|
|
async def contains(self, url, regex, rlist=True):
|
|
|
"""
|
|
|
Does url path matches a value in regex_list?
|
|
|
"""
|
|
|
retvalue = False
|
|
|
if rlist:
|
|
|
for exc in regex:
|
|
|
retvalue = bool(re.search(re.compile(r"{}".format(exc)), url))
|
|
|
if retvalue: return retvalue
|
|
|
else:
|
|
|
retvalue = bool(re.search(re.compile(r"{}".format(regex)), url))
|
|
|
return retvalue
|
|
|
|
|
|
async def urldict(self, url, url_dict):
|
|
|
"""
|
|
|
Parse URL regex (key) and value pairs
|
|
|
"""
|
|
|
for urlkey, regvalue in url_dict.items():
|
|
|
if await self.contains(url, urlkey, rlist=False):
|
|
|
return regvalue
|
|
|
return None
|
|
|
|
|
|
async def addurls(self, urls):
|
|
|
"""
|
|
|
Add urls in queue and run process to parse
|
|
|
:param urls:
|
|
|
:return:
|
|
|
"""
|
|
|
for url, parenturl in urls:
|
|
|
url = urllib.parse.urljoin(parenturl, url)
|
|
|
url, frag = urllib.parse.urldefrag(url)
|
|
|
|
|
|
if (url.startswith(self.rooturl) and
|
|
|
not await self.contains(url, self.exclude_urls, rlist=True) and
|
|
|
url not in self.busy and
|
|
|
url not in self.done and
|
|
|
url not in self.todo_queue):
|
|
|
self.todo_queue.add(url)
|
|
|
# Acquire semaphore
|
|
|
await self.sem.acquire()
|
|
|
# Create async task
|
|
|
task = asyncio.ensure_future(self.process(url))
|
|
|
# Add collback into task to release semaphore
|
|
|
task.add_done_callback(lambda t: self.sem.release())
|
|
|
# Callback to remove task from tasks
|
|
|
task.add_done_callback(self.tasks.remove)
|
|
|
# Add task into tasks
|
|
|
self.tasks.add(task)
|
|
|
|
|
|
async def mimechecker(self, url, expected):
|
|
|
"""
|
|
|
Check url resource mimetype
|
|
|
"""
|
|
|
try:
|
|
|
resp = await self.session.get(url)
|
|
|
except Exception as exc:
|
|
|
pass
|
|
|
else:
|
|
|
mime = resp.headers.get('content-type')
|
|
|
if (resp.status == 200 and
|
|
|
bool(re.search(re.compile(r"{}".format(expected)), mime))):
|
|
|
return True
|
|
|
return False
|
|
|
|
|
|
async def addimages(self, data):
|
|
|
"""
|
|
|
Find all images in website data
|
|
|
"""
|
|
|
imgs = []
|
|
|
imgs_ok = []
|
|
|
lines_tmp = []
|
|
|
tag = False
|
|
|
for line in data.split('\n'):
|
|
|
if re.search(r'<img', line):
|
|
|
tag = True
|
|
|
if re.search(r'<img', line) and re.search(r'\/>', line):
|
|
|
tag = False
|
|
|
lines_tmp.append(line)
|
|
|
continue
|
|
|
if re.search(r'\/>', line) and tag:
|
|
|
tag = False
|
|
|
if tag:
|
|
|
lines_tmp.append(line)
|
|
|
|
|
|
imgs = re.findall(r'(?i)src=["\']?([^\s\"\'<>]+)', str(lines_tmp))
|
|
|
|
|
|
for img in imgs:
|
|
|
if not await self.contains(img, self.exclude_imgs, rlist=True):
|
|
|
if img.startswith(self.rooturl):
|
|
|
if await self.mimechecker(img, '^image\/'):
|
|
|
imgs_ok.append(img)
|
|
|
elif not img.startswith("http"):
|
|
|
if await self.mimechecker(img, '^image\/'):
|
|
|
imgs_ok.append(re.sub('/$', '', self.rooturl) + img)
|
|
|
return imgs_ok
|
|
|
|
|
|
async def process(self, url):
|
|
|
"""
|
|
|
Process single url
|
|
|
:param url:
|
|
|
:return:
|
|
|
"""
|
|
|
print('processing:', url)
|
|
|
|
|
|
# remove url from basic queue and add it into busy list
|
|
|
self.todo_queue.remove(url)
|
|
|
self.busy.add(url)
|
|
|
|
|
|
lastmod = None
|
|
|
cf = None
|
|
|
pr = None
|
|
|
imgs = []
|
|
|
|
|
|
try:
|
|
|
resp = await self.session.get(url) # await response
|
|
|
except Exception as exc:
|
|
|
# on any exception mark url as BAD
|
|
|
print('...', url, 'has error', repr(str(exc)))
|
|
|
self.done[url] = [False, lastmod, cf, pr, imgs]
|
|
|
else:
|
|
|
# only url with status == 200 and content type == 'text/html' parsed
|
|
|
if (resp.status == 200 and
|
|
|
('text/html' in resp.headers.get('content-type'))):
|
|
|
data = (await resp.read()).decode('utf-8', 'replace')
|
|
|
urls = re.findall(r'(?i)href=["\']?([^\s"\'<>]+)', data)
|
|
|
lastmod = resp.headers.get('last-modified')
|
|
|
imgs = await self.addimages(data)
|
|
|
asyncio.Task(self.addurls([(u, url) for u in urls]))
|
|
|
|
|
|
try: pr = await self.urldict(url, self.changefreq)
|
|
|
except IndexError: pass
|
|
|
|
|
|
try: cf = await self.urldict(url, self.priorities)
|
|
|
except IndexError: pass
|
|
|
|
|
|
# even if we have no exception, we can mark url as good
|
|
|
resp.close()
|
|
|
|
|
|
self.done[url] = [True, lastmod, cf, pr, imgs]
|
|
|
|
|
|
self.busy.remove(url)
|
|
|
logging.info(len(self.done), 'completed tasks,', len(self.tasks),
|
|
|
'still pending, todo_queue', len(self.todo_queue))
|