Liberiamo la banda! Creamo un nuovo sistema di download.....

[Luci0]

Avevo pensato anch' io di creare un BigMegaPack.tgz con tutti i pacchetti e poi condividerlo con bittorrent o con emule ... basterebbe poi un scompattarlo per avere una repository in locale ed eventualmente configurare swaret o slapt-get in modo da utilizzarla ...

[V]

Creare un torrent per ogni singolo pacchetto è una stupidaggione, ci metti si o no 5 secondi....
IMHO creare un megapack non è una soluzione molto furba, avere un repository completo sul pc non è che serva a molto....
Se seguissimo lo standard bittorrent servirebbe solo fare un server modificato............

[masalapianta]

Creare un torrent per ogni singolo pacchetto è una stupidaggione, ci metti si o no 5 secondi....
IMHO creare un megapack non è una soluzione molto furba, avere un repository completo sul pc non è che serva a molto....
Se seguissimo lo standard bittorrent servirebbe solo fare un server modificato............

e modificare i vari PACKAGES.TXT aggiungendo un tag "PACKAGE TORRENT: $torrent" in modo che i vari client automatici (swaret, slapt-get) possano esser modificati per decidere se scaricare via http/ftp usando "PACKAGE LOCATION" o via bittorrent usando "PACKAGE TORRENT"; le modifiche da fare ai client sarebbero abbastanza banali (aggiungere uno switch da poter passare sulla cli per dire al client con che metodo scaricare e poi implementare la cosa nel client chiamando un programma client esterno bittorrent nel caso che si specifichi questo metodo di download)

[V]

Ok!
Quando si comincia?
Chi si aggiunge al progetto?

[Luci0]

...
IMHO creare un megapack non è una soluzione molto furba, avere un repository completo sul pc non è che serva a molto....
Se seguissimo lo standard bittorrent servirebbe solo fare un server modificato............

Secondo me tutti i pacchetti di Slacky non superano i 2Gbyte comunque per togliersi i dubbi si può calcolare dal ../Slacky.it/FILELIST.TXT...
Si potrebbe pubblicare periodicamente un torrent multifile della repository , o megapack comunque esiste un problema di allineamento tra le versioni... una directory stable andrebbe comunque creata, e poi una current con gli update ...

[masalapianta]

dunque, imho l'accrocco dovrebbe essere cosi' concepito:

1) ai PACKAGES.TXT va aggiunto un tag "PACKAGE TORRENT" (potrebbe anche non servire, in quanto il torrent lo si puo' chiamare come il tgz ma con estensione .torrent e quindi la url per scaricarlo la si ricava dagli altri tag, ma cosi' e' possibile gestire un repository misto con pacchetti disponibili solo via http/ftp e pacchetti disponibili anche via torrent e sapere se un pacchetto ha il torrent senza provare a scaricarlo); quindi ad esempio:

Codice: Seleziona tutto

PACKAGE NAME:  unixodbc-2.2.12-i486-1sl.tgz 
PACKAGE TORRENT: unixodbc-2.2.12-i486-1sl.torrent
PACKAGE LOCATION:  ./database/unixodbc/2.2.12
PACKAGE SIZE (compressed):  1267 K
PACKAGE SIZE (uncompressed):  4130 K
PACKAGE REQUIRED:  cxxlibs >= 6.0.3-i486-1 | gcc-g++ >= 3.4.6-i486-1,expat >= 1.95.8-i486-1,fontconfig >= 2.2.3-i486-2,freetype >= 2.1.9-i486-1,gcc >= 3.4.6-i486-1,glibc-solibs >= 2.3.6-i486-6,libjpeg >= 6b-i386-4,libmng >= 1.0.5-i486-1,libpng >= 1.2.12-i486-2,ncurses >= 5.5-i486-1,qt >= 3.3.6-i486-4,readline >= 5.1-i486-1,x11 >= 6.9.0-i486-11,zlib >= 1.2.3-i486-1PACKAGE CONFLICTS:  
PACKAGE SUGGESTS:  
PACKAGE DESCRIPTION:
ecc...

2) ogni pacchetto che ha un torrent conterra' nella directory specificata in "PACKAGE LOCATION" un torrent file con il nome specificato da "PACKAGE TORRENT"

3) deve girare h24 un client bittorrent che tenga sempre aperti i torrent file (la scelta piu' ovvia sarebbe farlo girare sulla macchina che hosta slacky.it)

4) un gestore di pacchetti per supportare i torrent dovrebbe leggere il tag "PACKAGE TORRENT" quando parserizza i PACKAGE.TXT, permettere di specificare se usare http/ftp o torrent per scaricare un pacchetto e nel caso si scelga torrent deve scaricare dal repository il torrent file e poi avviare il download del torrent chiamando, tramite system() (e possibilmente legandolo mani e piedi al suo stdin/stdout tramite dup2() o meccanismo analogo), il client bittorrent e passandogli il torrent file appena scaricato dal repository.
Attualmente i due gestori di pacchetti di slackwar sono swaret e slapt-get:
swaret e' un accrocco blobboso di shell scripting, quindi molto semplice da modificare ma meno conveniente perche' il software in se fa schifo
slap-get e' fatto meglio ma bisogna conoscere il C per modificarlo (c'e' pero' da dire che le modifiche son poche e abbastanza banali, quindi non bisogna certo essere Wietse Venema per farle).
Terza possibilita' e' scrivere un client da zero che come uniche funzionalita' abbia il poter scaricare e installare un pacchetto e automaticamente le sue dipendenze via torrent; e visto che oggi al lavoro e' una giornata piatta in una ventina di minuti di fancazzismo ho scritto una libreria perl allo scopo:

Codice: Seleziona tutto

package SlackPkg;

use strict;
use warnings;
use LWP::Simple;

our $VERSION = '0.01';

sub new {
	my ($this, $file) = @_;
	my $class = ref($this) || $this;
	my $self = {
                        packfile => $file,
                   };
        bless $self, $class;
	my @packload;
	my @packarr;
	my %packhash;
	my $rifHash;
	my $descflag = 0;
	my $description;
	my $name;
	my $location;
	my $sizecomp;
	my $sizeuncomp;
	my $required;
	my $conflicts;
	my $suggests;
	my $descname;
	my $version;
	my $torrent;

	return 0 unless (-f "$self->{packfile}/PACKAGES.TXT");

	open(PFILE,"$self->{packfile}/PACKAGES.TXT");
	while(<PFILE>) {
		push(@packload,$_);
	}
	close(PFILE);

	foreach(@packload) {
		chomp();
		$descflag = 0 if( $_ eq '');
		if($descflag eq 1 && m/^(\S+):\s*(.*)/) {
			$description .= $2."\n";
			$descname = $1;
			my $quoteddescname = quotemeta $descname;
			$version = $1 if($name=~m/.*$quoteddescname-(.*)\.tgz.*/);
			next;
		}
		$location = $1 if(m/PACKAGE LOCATION:\s*(.+)/);
		$sizecomp = $1 if(m/PACKAGE SIZE \(compressed\):\s*(.+)/);
		$sizeuncomp = $1 if(m/PACKAGE SIZE \(uncompressed\):\s*(.+)/);
		$required = $1 if(m/PACKAGE REQUIRED:\s*(.+)/);
		$conflicts = $1 if(m/PACKAGE CONFLICTS:\s*(.+)/);
		$suggests = $1 if(m/PACKAGE SUGGESTS:\s*(.+)/);
		$torrent = $1 if(m/PACKAGE TORRENT:\s*(.+)/);
		$descflag = 1 if(m/PACKAGE DESCRIPTION:\s*/);
		if(m/PACKAGE NAME:\s*(.+)/) {
	                $rifHash = {
	                                'name' => $name,
	                                'location' => $location,
	                                'sizecomp' => $sizecomp,
	                                'sizeuncomp' => $sizeuncomp,
	                                'required' => $required,
	                                'conflicts' => $conflicts,
	                                'suggests' => $suggests,
	                                'description' => $description,
					'descname' => $descname,
					'version' => $version,
					'torrent' => $torrent,
	                           };
	                push @packarr, $rifHash;
	                undef($description);
	                $name = $1;
	        }
	}
	$rifHash = {
			'name' => $name,
	                'location' => $location,
	                'sizecomp' => $sizecomp,
	                'sizeuncomp' => $sizeuncomp,
	                'required' => $required,
	                'conflicts' => $conflicts,
	                'suggests' => $suggests,
	                'description' => $description,
			'descname' => $descname,
			'version' => $version,
			'torrent' => $torrent,
	            };
	push @packarr, $rifHash;
	$self->{allpackref}=\@packarr;
	return $self;
}

sub all {
	my $self = shift;
	return $self->{allpackref}
}

sub search {
	my ($self, $searchstring) = @_;
	my $packref = $self->{allpackref};
	my @results;
	foreach (@{ $packref }) {
		if(defined(${ $_ }{name}) && defined(${ $_ }{description})) {
			push @results, $_ if(${ $_ }{name}=~m/^.*$searchstring.*$/i || ${ $_ }{description}=~m/^.*$searchstring.*$/i);
		}
	}
	return \@results;
}

sub show {
	my ($self, $packname) = @_;
        my $packref = $self->{allpackref};
	foreach (@{ $packref }) {
		if(defined(${ $_ }{descname})) {
			return $_ if(${ $_ }{descname}=~m/^$packname$/i);
		}
	}
}

sub update {
	my ($self, $repos, $cachedir) = @_;
	if ( ! -d "$cachedir" ) { mkdir("$cachedir"); }
	my $getresults = get( "$repos/PACKAGES.TXT" ) or return 0;
        open(PFILE,"> $cachedir/PACKAGES.TXT") or return 0;
	print PFILE $getresults;
        close(PFILE);
	return 1;
}

sub show_dep {
	my ($self, $packname) = @_;
	my $packref = $self->{allpackref};
	my $required;
        foreach (@{ $packref }) {
                if(defined(${ $_ }{descname}) && ${ $_ }{descname}=~m/^$packname$/i) {
			$required = ${ $_ }{required};
			last;
                }
        }
	my @deparr = split(/,/,$required);
	return \@deparr;
}

esempio 'duso:

Codice: Seleziona tutto

#!/usr/bin/perl

use strict;
use warnings;
use SlackPkg;

my %packhash;
my $packref;
my $slackpack;


mkdir("/tmp/slacky.it") if ( ! -d "/tmp/slacky.it" );
my $result=`wget -O '/tmp/slacky.it/PACKAGES.TXT' 'http://www.slacky.eu/repository/slackware-11.0/PACKAGES.TXT' &> /dev/null` unless( -f '/tmp/slacky.it/PACKAGES.TXT');


# il costruttore prende come argomento il il path assoluto alla
# directory di cache del repository e torna 0 in caso di
# problemi
$slackpack = SlackPkg->new('/tmp/slacky.it');
# -------------------------------------------------------------------------------------------


# il metodo all torna un riferimento ad un array di riferimenti 
# a degli hash, (le chiavi di ogni hash sono i tag di un pacchetto
# nel file PACKAGES.TXT e i valori sono i valori del tag)
#my $packref=$slackpack->all();
# -------------------------------------------------------------------------------------------


# il metodo search torna la stessa cosa di all ma non per tutti i
# pacchetti, ma solo per quelli i cui tag "PACKAGE NAME:" e 
# "PACKAGE DESCRIPTION:" contengono la chiave di ricerca che search
# prende come unico argomento (la ricerca e' case insensitive)
$packref=$slackpack->search('wine');
foreach (@{ $packref }) {
        my %packhash = %{ $_ };
        print "name: $packhash{name}\n" if(defined($packhash{name}));
        print "torrent: $packhash{torrent}\n" if(defined($packhash{torrent}));
        print "location: $packhash{location}\n" if(defined($packhash{location}));
        print "sizecomp: $packhash{sizecomp}\n" if(defined($packhash{sizecomp}));
        print "sizeuncomp: $packhash{sizeuncomp}\n" if(defined($packhash{sizeuncomp}));
        print "required: $packhash{required}\n" if(defined($packhash{required}));
        print "conflicts: $packhash{conflicts}\n" if(defined($packhash{conflicts}));
        print "suggests: $packhash{suggests}\n" if(defined($packhash{suggests}));
	print "descname: $packhash{descname}\n" if(defined($packhash{descname}));
        print "description: $packhash{description}\n" if(defined($packhash{description}));
        %packhash=();
}
undef %packhash;
undef $packref;
print "-------------------------------------------------------------------------------------------\n\n";
# -------------------------------------------------------------------------------------------


# il metodo show torna un riferimento ad un hash (le chiavi dell'hash sono 
# i tag di un pacchetto nel file PACKAGES.TXT e i valori sono i valori del 
# tag), prende come argomento il nome d'un pacchetto
$packref=$slackpack->show('wine');
%packhash = %{ $packref };
my $name=$packhash{name};
my $descname=$packhash{descname};
my $version=$packhash{version};
my $torrent=$packhash{torrent};
print "name: $name\n";
print "descname: $descname\n";
print "version: $version\n";
print "torrent: $torrent\n";
undef %packhash;
undef $packref;
print "-------------------------------------------------------------------------------------------\n\n";
# -------------------------------------------------------------------------------------------


# il metodo update scarica un PACKAGES.TXT da un repository (che prende come
# primo argomento) e lo scrive in una directory (che prende come secondo 
# argomento)
$slackpack->update('http://www.slacky.eu/repository/slackware-11.0/','/tmp/slacky.it') 
	and print "Updated repos: /tmp/slacky.it\n";
print "-------------------------------------------------------------------------------------------\n\n";
# -------------------------------------------------------------------------------------------


# il metodo show_dep prende come argomento il nome d'un pacchetto e torna
# un riferimento ad un array che contiene le dipendenze del pacchetto 
my $depRef = $slackpack->show_dep('wine');
my @dep = @{ $depRef };
foreach(@dep) {
	print "wine dep: $_\n";
}
print "-------------------------------------------------------------------------------------------\n\n";
# -------------------------------------------------------------------------------------------

la libreria implementa metodi per il parsing, l'update, il search e la lista delle dipendenze dei pacchetti d'un repository; utilizzandola e' relativamente semplice scrivere un client che permetta di scaricare un pacchetto e le sue dipendenze via http/ftp o torrent;
per la gestione delle dipendenze fate riferimento a questa FAQ:
http://software.jaos.org/BUILD/slapt-ge ... l#slgFAQ19

[gioco]

dunque, imho l'accrocco dovrebbe essere cosi' concepito:

Ottimo. Grazie davvero, considerato anche che tu usi debian e probabilmente non usufruirai del nuovo sistema
Mi sembra un modo semplice e pulito per gestire la cosa. Io posso dare una mano con i client (sia per le modifiche a swaret/slapt-get che per la scrittura del client nuovo di zecca).
A questo punto possiamo dividerci e il lavoro e spostare la discussione su una ML aperta a tutti gli interessati con la quale coordinarci. Che ne dite?

[V]

Uffa.............
Se si fa qualcosa in perl non posso essere utile..............

[diego]

La butto li, ma forse e' gia venuto in mente a qualcuno (e/o gia scartata):
perche' non usare un repositori con i sorgenti+slackbuild?
Un programma tipo slapt-get che scarica i sorgenti+slackbuild con relative
dipendenze e dopo compila con le ottimizzazioni del proprio pc e intstalla/aggiorna.
Meno spazio occupato sul repository, meno tempo di download e quindi meno banda
occupata.
Addirittura sullo Slackbuild (quando possibile) potrebbe esserci un comando wget
che scarica il sorgente direttamente dal sito del maintainer.
A me come idea non sembra malvagia anche se sa un po' da FreeBSD/Gentoo,
ma cosi' su due piedi non saprei come realizzarla.

[masalapianta]

La butto li, ma forse e' gia venuto in mente a qualcuno (e/o gia scartata):
perche' non usare un repositori con i sorgenti+slackbuild?
Un programma tipo slapt-get che scarica i sorgenti+slackbuild con relative
dipendenze e dopo compila con le ottimizzazioni del proprio pc e intstalla/aggiorna.
Meno spazio occupato sul repository, meno tempo di download e quindi meno banda
occupata.

eh? guarda che solitamente i sorgenti sono piu' grossi dei binari compilati da essi

[gioco]

Uffa.............
Se si fa qualcosa in perl non posso essere utile..............

Di perl non so nulla neanche io. Sono più attrezzato per il C e il bash scripting.

[gioco]

La butto li, ma forse e' gia venuto in mente a qualcuno (e/o gia scartata):
perche' non usare un repositori con i sorgenti+slackbuild?
Un programma tipo slapt-get che scarica i sorgenti+slackbuild con relative
dipendenze e dopo compila con le ottimizzazioni del proprio pc e intstalla/aggiorna.
Meno spazio occupato sul repository, meno tempo di download e quindi meno banda
occupata.
Addirittura sullo Slackbuild (quando possibile) potrebbe esserci un comando wget
che scarica il sorgente direttamente dal sito del maintainer.
A me come idea non sembra malvagia anche se sa un po' da FreeBSD/Gentoo,
ma cosi' su due piedi non saprei come realizzarla.

Ci sono già questi:
http://portpkg.berlios.de/
http://emerde.freaknet.org/
Al di la del fatto che i sorgenti sono più pesanti dei binari, ricompilarsi tutto può essere una gran noia (io mi devo già ricompilare i pacchetti per PPC).

[diego]

perche' non usare un repositori con i sorgenti+slackbuild?

eh? guarda che solitamente i sorgenti sono piu' grossi dei binari compilati da essi

ok come non detto, mi sa che lo sparata grossa, chissa cosa avevo in mente

@gioco
grazie per i link

[danix]

@ Loris
Ti rispondo qui per mantenere la discussione sull'argomento torrent meno dispersiva, non sono un esperto, utilizzo torrent di frequente per scaricare perchè lo trovo molto comodo, l'unico "problema" è che lo si può utilizzare solo con le novità, ma per l'uso che dovrebbe farne slacky credo vada più che bene...
Per creare un torrent ho trovato makeTorrent, come tracker si potrebbe utilizzare l'ex suprnova snarf-it.org, piuttosto che freetorrent (tracker creato per la distribuzione di software OpenSource, sarebbe il massimo, l'unico problema è che il sito è in francese....) oppure si potrebbe utilizzare anche piratebay che è uno dei migliori che io abbia mai visto... comunque renditi conto che basta una ricerca su google e di tracker ne trovi a migliaia...
Poi basterebbe mettere in seed il file dal server di slacky fin quando almeno 3 o 4 persone non lo scaricano completamente, da li basta che queste persone lo lascino disponibile agli altri e il traffico verrebbe diviso anche su di loro lasciando la banda di slacky abbastanza fruibile da chi non usa torrent...
Per renderlo disponibile sul proprio pc basta mettere il tgz (nel nostro caso) in una directory in cui ci fa comodo lasciarlo e lasciare attivo il client torrent a fare sharing almeno fino all'80% delle dimensioni del file condiviso, in questo modo si assicura la possibilità a tutti di fruire di quel file senza gravare troppo su slacky... L'unica cosa che dovresti fare è mettere a disposizione di tutti una md5 o una sha1 del tgz originale in modo da confrontare ed essere sicuri di aver scaricato il file senza corruzioni...

Spero di essere stato abbastanza chiaro, non ho letto tutto il 3d prima di postare e mi scuso se ho detto qualcosa che era già stato detto prima...

[IceSlack]

soulseek?