viewgit/index.php:465 Only variables should be passed by reference [2048]
viewgit/index.php:466 Non-static method GeSHi::get_language_name_from_extension() should not be called statically [2048]
# # -*- coding: utf-8 -*- # import random import urllib2 import mutex import threading import re, time default_page = "http://poisson.phc.unipi.it" __author__ = "Leonardo Robol <leo@robol.it>" mtx_url_dict = mutex.mutex() N = 10000 url_dict = {} url_counter = range(N) max_steps = 5 def get_links(page): """Restituisce una lista con i link presenti nella pagina data, in forma canonica""" content = get_page(page.url) if(content == -1): return -1 links = re.findall(r"<a href=\"(\S*)\"[^>]*>",content) ret = [] for link in links: # Espando il link in modo da (speriamo!) # garantire l'unicità ret.append(expand_url(page.url, link)) return ret def expand_url(parent, url): """Questa funzione prende l'url della pagina parent e l'url del link e dà all'url del link una forma unica e canonica, del tipo http://www.example.com/pagina http://www.example.com/pagina.html """ ## Controllo che l'url non cominci con un punto ## nel qual caso cerchiamo di rimediare subito, ## ma non cadiamo nel tranello di ignorare i .. if url[0] == ".": if len(url) == 1: url = parent else: if(url[1] != "."): url = url[1:] ## Se all'inizio dell'url c'è uno slash non ci serve tutto ## il parent, ma solo la prima parte if url.startswith("/"): parent = re.search(".+//[^/]*", parent).group(0) else: # in caso contrario dobbiamo assicurarci di troncare # l'ultima parte dell'url dopo il /, a meno che non # finisca senza estensione (in quel caso aggiungiamo un /) if re.search("\.[^/]*$", parent): parent = re.sub("[^/]*$", "", parent) else: parent += "/" ## Controlliamo prima di tutto se nell'url c'è un ## protocollo protocol = re.search(r"(\w+):", url) if protocol == None: url = parent + url return url def get_page(url): """Cerca di scaricare l'url dato e restituisce -1 se non ce la fa, il contenuto altrimenti""" try: req = urllib2.urlopen(url) except: return -1 return req.read() class Page(): """Una pagina web. Questa classe, quando viene istanziata, controlla se una pagina con quel nome è già presente (una pagina è unica!) e se lo è restituisce lo stesso oggetto, altrimenti ne crea uno nuovo con un nuovo ID""" def __repr__(self): return "<Page object: %s>" % self.url def __init__(self, url=""): if(url != ""): mtx_url_dict.lock(self.__new_page, url) mtx_url_dict.unlock() else: mtx_url_dict.lock(self.__get_page, 0) mtx_url_dict.unlock() def __get_page(self, num): if(len(url_counter) == 0): self.exhausted = True return page_found = False while(not page_found): for url in url_dict: page = Page(url) if not page.analyzed: page_found = True self.url = url break if not page_found: time.sleep(1) self.ID = page.ID self.analyzed = page.analyzed self.exhausted = False url_dict[url].analyzed = True def __new_page(self, url): # Questo ci serve per tenere il # conto di tutti gli url global url_dict global url_counter self.exhausted = False self.analyzed = False self.url = url if(url_dict.has_key(url)): # Preservo i parametri che esistono già! self.ID = url_dict[url].ID self.analyzed = url_dict[url].analyzed else: try: self.ID = url_counter.pop() except IndexError: self.exhausted = True url_dict[url] = self url_dict[url].links = [] def add_link(self, page): if(page.exhausted): return -1 print " => Adding link to %s" % page.url mtx_url_dict.lock(self.__add_link, page.ID) mtx_url_dict.unlock() return 0 def __add_link(self, ID): url_dict[self.url].links.append(ID) def links(self): return url_dict[self.url].links class Crawler(threading.Thread): """Partendo da startpage, segue tutti i link registrando i vari collegamenti fra le pagine. Una volta raggiunto il limite di pagine da controllare termina""" def __init__(self, startpage=default_page): threading.Thread.__init__(self) self.start_page = startpage def run(self): step_counter = 0 # Capiamo che pagina ci serve page = Page(self.start_page) while(not page.exhausted): if(step_counter > max_steps): page = Page(self.start_page) step_counter = 0 else: page = Page() step_counter += 1 if page.exhausted: break # Come prima cosa devo fare il parsing dei # link che ci sono nella pagina # Diamo una mixata per simulare meglio # il caso.. dato che tanto è probabile che # alcuni link rimarranno non visitati! links = get_links(page) random.shuffle(links) ## A questo punto io che mi occupo della pagina devo ## aggiungere tutti i link alla pagina if not links == -1: for l in links: lpage = Page(l) if not lpage.exhausted: page.add_link(lpage) else: break if __name__ == "__main__": concurrency = 25 threads = [] for i in range(0, concurrency): threads.append(Crawler()) threads[i].start() for i in range(0, concurrency): threads[i].join() ## A questo punto mi devo preoccupare di salvare ## la matrice in un formato soddisfacente out = open("ji.txt", 'w') for page in url_dict: for link in url_dict[page].links: out.write(page + "\t" + str(url_dict[page].ID) + "\t" + str(link) + "\n")