frafra.eu

Vi è mai capitato di dover (o voler) scaricare l’ultima versione di uno o più programmi? O sapere semplicemente se è stato rilasciato un aggiornamento?
Bene, a Frafra queste cose capitano, soprattutto quando si parla di sorgenti, compilazione, e compagnia cantante

Ho creato un programma Python (>= 3.x, testato su 3.1.1), che risolve automaticamente questo problema, con l’uso di un parser e di un crawler Sono cento linee giuste giuste, parzialmente commentate, con tanto di licenza (questa volta metto il file per intero, perché in primo luogo ho raggiunto un numero di linee tondo tondo, e in secondo luogo perché la prima linea è molto importante).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# takeit.py
#
# Copyright 2009 Francesco Frassinelli <fraph24@gmail.com>
#
#     This program is free software: you can redistribute it and/or modify
#     it under the terms of the GNU General Public License as published by
#     the Free Software Foundation, either version 3 of the License, or
#     (at your option) any later version.
#    
#     This program is distributed in the hope that it will be useful,
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#     GNU General Public License for more details.
#    
#     You should have received a copy of the GNU General Public License
#     along with this program. If not, see <http://www.gnu.org/licenses/>.
 
""" This program shows you the latest version of a source package """
 
### HTMLParser patched version, see: http://bugs.python.org/issue755660
# $ cp /usr/local/lib/python3.1/html/parser.py HTMLParser.py
# $ wget http://bugs.python.org/file13041/htmlparser_error.diff
# $ patch -p0 HTMLParser.py < htmlparser_error.diff
import HTMLParser
import re, sys, urllib.request
 
servers = {
    "gnu":"http://ftp.gnu.org/gnu/",
    "linux":"http://ftp.kernel.org/pub/linux/",
    "vim":"http://ftp.vim.org/pub/vim/unix/",
} # List of available servers: add yours and report test them
 
class Parser(HTMLParser.HTMLParser):
    def __init__(self, page, callback):
        super(Parser, self).__init__()
        self.callback = callback
        self.page = page # Current page
    def handle_starttag(self, tag, attrs):
        if tag == "a":
            attrs = dict(attrs)
            if "href" in attrs:
                self.callback(self.page, attrs["href"])
    def error(self, message):
        pass # Overwriting default function, in order to skip any error
 
class Crawler:
    def __init__(self):
        self.source = re.compile(r"""^
            (.+?)-                  # package name
            ([\d\.-]+)              # version
            \.(tar\.bz2|tar\.gz)    # compression
            $""", re.VERBOSE) # VERBOSE is for multiline commented regex
        self.packages = dict()
    def inspect(self, page):
        print("I'm in:", page) # If there're errors, report it *always*
        with urllib.request.urlopen(page) as data:
            parser = Parser(page, self.callback)
            parser.feed(data.read().decode("utf_8", "ignore"))
            parser.close()
    def item(self, page, link):
        if self.source.match(link):
            res = self.source.search(link)
            package, version, compression = res.groups()
            if package == "0": # Should we use re.match("^\d+$", package)?
                return # Not properly detected: regex could be wrong
            if package not in self.packages:
                self.packages[package] = list()
            self.packages[package].append((version, page + link))
    def callback(self, page, link):
        # Special link / Backwards link / External link or absolute path
        useless = "?" in link or ".." in link or link.count("/") > 1
        if not useless:
            if link.endswith("/"):
                self.inspect(page + link) # Directory: recursive function
            else:
                self.item(page, link) # File: analize its name
    def results(self):
        for package, version in sorted(self.packages.items()):
            version, url = sorted(version, reverse = True)[0]
            yield package, version, url # Just to iterate it
 
def mycrawler(base, directory = ""):
    crawler = Crawler()
    crawler.inspect(base + directory)
    for package, version, url in crawler.results():
        print() # Newline ("\n")
        print("Name:", package)
        print(" -> Version:", version)
        print(" -> URL:", url)
 
if __name__ == "__main__":
    args = len(sys.argv)
    base      = (servers[sys.argv[1]],) if args > 1 else servers.values()
    directory = set(sys.argv[2:])       if args > 2 else ("",)
    for server in base:
        for page in directory:
            mycrawler(server, page)

frafra Linux, Python parser, Python, sorgenti

Il guardiano del router e compagna

Proprio ieri sono stato privato della mia linea ADSL casalinga (sto traslocando). In un primo momento, sono stato preso dal panico, pensando a un malfunzionamento del router (basato su Linux, ha sempre funzionato benissimo). Nonostante nella mia testa iniziasse a girovagare l’idea che mi avessero staccato la linea, per i primi 30 minuti il mio cervello non accettava il fatto, come quando viene a mancare un animale domestico al quale si è affezionati e nonostante ciò gli si riempie la ciotola di pappa Dopo qualche reboot dei miei tre scatolotti necessari per far funzionare la mia rete (un modem ethernet, un router 4 porte wifi, e uno switch 8 porte), ho guardato il “guardiano del router” (un piccolo pinguino di peluche che tiene lontani gli spiriti cattivi dalla mia connessione), e gli ho detto: “mi dispiace, per un po’ ti toccherà fare il disoccupato…”.

Detto ciò, ho passato un po’ di tempo a sistemare i miei programmini Python, e a pubblicare su github un po’ di codice (vedasi github.com/frafra, dove ho pubblicato anche una interessante applicazione PyQT4+Twisted per la chat), utilizzando il pc di un amico Questo mio amico (nonché vicino di casa), ha acconsentito a condividere temporaneamente la sua connessione wifi. E qui inizia il divertimento

Obiettivo: dare internet alla lan, utilizzando una rete wifi

Sostanzialmente, abbiamo bisogno di un pc che da una parte si connetta dalla rete wireless, e dall’altra condivida la propria connessione. Per fare ciò sul pc dotato sia di scheda wireless sia di scheda ethernet dobbiamo:

1. Connetterci alla rete (soluzione più semplice: networkmanager)
2. ifconfig eth0 192.168.100.1 up
   (ho scelto 192.168.100.1 perché così sono sicuro che non si tratti di una rete già in uso)
3. echo 1 > /proc/sys/net/ipv4/ip_forward
4. iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE
   (dove eth0 è l’inferfaccia di rete e wlan0 quella wifi)
5. Installare dnsmasq
6. Editare /etc/dnsmasq.conf, mettendo:
   domain-needed
bogus-priv
interface=eth0
dhcp-range=192.168.100.2,192.168.100.100,12h
7. Avviare il demone dnsmasq
   (spesso basta dare /etc/init.d/dnsmasq start o /etc/rc.d/dnsmasq start)

Tutti questi comandi devono essere avviati come superutente (quindi o aggiungendo sudo davanti a ogni comando, o digitando su [invio] prima di iniziare la procedura). Dagli altri computer ora potete connettervi come se fosse presente un normale router nella rete locale (quindi con networkmanger, o lanciando un dhclient/dhcpcd eth0), e il gioco è fatto Per collegare più dispositivi alla rete del mio portatile, ho collegato i vari computer (incluso il portatile) allo switch. Nulla di più facile

Ecco che, grazie alle mie doti nell’arte figurativa (eeeh!) e a inkscape, ho creato una mappa della rete, prima e dopo

P.S. Ehi, ho appena fatto 19 anni, sto invecchiando Domani si parte per l’avventura chiamata “università”

frafra Frafra, Guide, Linux connection sharing, dnsmasq, iptables

L’anestesista più chiacchierato nel mondo del software libero è tornato a due anni di distanza, dopo l’abbandono dello sviluppo del suo set di patch al kernel Linux (chi non si ricorda il patchset -ck?).

Per ora non pare sia interessato alla mainline di Linux, però ha già rilasciato del codice interessante. Cosa avrà mai sviluppato? Uno scheduler ovviamente Perché? Perché Linux è migliorato molto sotto questo aspetto, ma lo scheduler attuale, stando alle parole del nostro eroe, è adatto principalmente per macchine con molti processori, e passa molto tempo calcolando come bilanciare il carico. Kolivas ha fatto uno scheduler che, al contrario, va meglio sui normali computer, meglio se con un paio di cpu

Ecco il covo! ck.kolivas.org/patches/bfs/

frafra Linux, News con kolivas, kernel, Linux