Programmation en architecture distribué

Version imprimable

15/01/2007, 00h25
mobscene

Programmation en architecture distribué

Je bosse depuis l'an dernier sur un moteur de recherche programmé en perl de A a Z il n'est pas encore fini mais j'ai quelques soucies c'est vraiment fastidieux de passer d'une TSE a un autre pour voir ce qui ce passe , je voudrais donc faire une interface graphique (ou en ligne de commande) pour récupérer les logs des crawlers ,indexeurs, scheduler ainsi que pour les controler a distance etc...

Je me penche sur cette question depuis quelques jours mais je ne sais pas comment faire vue que c'est mon premier programme en architecture distribué.

Je voudrais donc avoir vos avis sur les solutions techniques a adopté. Ma première idée a été biensur d'utilise un système de socket mais ce n'est pas allé plus loin que le modèle papier sa complieque les softs et sa fait un peut trop de port ouvret je trouve. J'ai aussi pensé a utilisé WDFS.

voila voila merci de vos suggestions
15/01/2007, 00h34
pospos

le plus simple (si j'ai bien compris ce que tu voulais faire) est d'utiliser un systeme de message.
Exemple : http://search.cpan.org/~audreyt/IPC-PubSub/

(et eventuellement d'utiliser HTTP ou NFS pour recuperer les gros trucs, dont tu aurait recu l'adresse par le systeme de message)
15/01/2007, 01h37
mobscene

Merci Pospos ce module m'a l'air très interessant je vais tester tout sa :8-)
15/01/2007, 23h38
mobscene

J'ai testé ce module il me convient bien 8-) , je vais m'en servir pour recoder le gestionnaire d'indexeurs parce que j'utilise des threads et sa bouffe beaucoup de ram pis la stabilité sa dépend du sens du vent.

Je vais donc forker a la placer et utiliser ce module pour que chaque fils s'abonne au canal pour y pousser des infos enfin sont pid avant de claquer :aie: .
16/01/2007, 12h14
pospos

si tu veux pouvoir utiliser la semantique des threads sans leurs limites (bugs) regarde du coté du module/pragma forks

http://search.cpan.org/~rybskej/forks-0.20/

(si tu est sous unix evidemment)
16/01/2007, 14h10
mobscene

Je suis sous Windows XP :?.

La pile Win32 ne prend pas fork() mais la pile POSIX et la pile OS/2 de Windows le supporte non ???
16/01/2007, 14h40
pospos

pas de fork sous windows (il est emulé avec des threads)
si tu veux qulques chose qui se rapproche vraiment de process alors utilise Win32::Process (mais tu n'aura pas de copy on write evidemment)

Perso je m'etais orienté sur Parallel::Forkmanager, j'ai fait ce script pour tester mon idée et bah sa marche pas :aie: il y a un blocage mais j'arrive pas déterminer ou :mouarf:

Code:

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
#!/usr/bin/perl -w
use strict;
use diagnostics;
 
package TESTE;
use Parallel::ForkManager;
use IPC::PubSub;
use vars qw($pub $sub);
 
sub new
{
   my $this = {};
   $this->{IPC} = IPC::PubSub->new(DBM_Deep => 'channel.txt');
   $pub = $this->{IPC}->new_publisher("#perl6","#moose");
   bless($this,shift);
   return $this;
}
 
sub run
{
  # define publisher
  #$pub = $_[0]->{IPC}->new_publisher("#perl6","#moose");
 
  my $pid = fork();
 
  if ($pid)
  {
    $sub = $_[0]->{IPC}->new_subscriber("#father");
    while (1)
    {
      eval {
        my @msgs = $sub->get('#perl6');
        if ( scalar @msgs > 0)
        {
          print "$msgs[0]->{gna}\n";
        }
      };
    }
  }
   else
  {
     my @names = qw( Fred Jim Lily Steve Jessica Bob Dave Christine Rico Sara );
     # hash to resolve PID's back to child specific information
 
     my $pm =  new Parallel::ForkManager(5);
 
     # Setup a callback for when a child finishes up so we can
     # get it's exit code
     $pm->run_on_finish(
       sub { my ($pid, $exit_code, $ident) = @_;
       #  print "** $ident just got out of the pool ".
          # "with PID $pid and exit code: $exit_code\n";
       }
     );
 
     $pm->run_on_start(
       sub { my ($pid,$ident) = @_;
        # print "** $ident started, pid: $pid\n";
       }
     );
 
     $pm->run_on_wait(
       sub {
        # print "** Have to wait for one children ...\n"
       },
       1,
     );
 
     foreach my $child ( 0 .. $#names )
     {
       my $pid = $pm->start("$names[$child]") and next;
       # This code is the child process
      # print "This is $names[$child], Child number $child\n";
 
       eval {
        # Add data to publisher!!
         #$pub = $_[0]->{IPC}->new_publisher("#moose");
         my $mp = "This is child $pid $names[$child] hello :)";
         $pub->msg({ 'gna' => $mp });
       };   
       #sleep ( 2 * $child );
 
      # print "$names[$child], Child $child is about to get out...\n";
     #  sleep 1;
       $pm->finish($child); # pass an exit code to finish
     }
    print "Waiting for Children...\n";
    $pm->wait_all_children;
    print "Everybody is out of the pool!\n";
  }
}
 
 
package main;
import TESTE;
 
my $i = new TESTE;
 
$i->run;