Remote Update Protocol

[ Home ] [ Sources ] [ FAQ ] [ Notes / Rapport ] [ Architecture ] [ Installer RUP ]

Presentation des fichiers sources...
Au moment de produire cette page un script shell (echo, head) extrait
les commentaires (en tete) des fichiers de type .ml ou .mli.

Sources OCaml
-- HEAD COMMENTS SCRATCHED FROM SOURCES FILES --

==> ../../bd_rup_index.ml <==
(* Format des données
     * la base est une suite de fiches séparées par des retour-chariot ;
     * chaque fiche est une suite de champs séparés par un caractère
       quelconque que nous supposerons ici être le caractère ':' ;
     * un champ est une chaîne de caractères qui ne contient ni
       retour-chariot, ni le caractère ':' ;
     * la première fiche est la liste des noms associés aux champs



==> ../../bd_rup_robottxt.ml <==
(* Format des données
     * la base est une suite de fiches séparées par des retour-chariot ;
     * chaque fiche est une suite de champs séparés par un caractère
       quelconque que nous supposerons ici être le caractère '{' ;
     * un champ est une chaîne de caractères qui ne contient ni
       retour-chariot, ni le caractère '{' ;
     * la première fiche est la liste des noms associés aux champs



==> ../../bd_ruppref.ml <==
(* Format des données
     * la base est une suite de fiches séparées par des retour-chariot ;
     * chaque fiche est une suite de champs séparés par un caractère
       quelconque que nous supposerons ici être le caractère '{' ;
     * un champ est une chaîne de caractères qui ne contient ni
       retour-chariot, ni le caractère '{' ;
     * la première fiche est la liste des noms associés aux champs



==> ../../main_client.ml <==
(* main_client.ml - client robot RUP, supporte le protocole HTTP
   Un client doit pouvoir :   
   - construire un objet rupcmd (qui decrit la commande rup ainsi que ses composants)
   - communiquer avec un serveur rup, ie : envoyer la commande + traiter la reponse.
   Lancer le client :
   rup_client -host adresse_serveur -cmd commandeRUP -f fichier
   par exemple : rup_client -host machine.chez.bidule -cmd register -f toto -v 



==> ../../mimestring.ml <==
(* $Id: mimestring.ml,v 1.8 2000/08/13 00:04:36 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)

module Str = Netstring_str;;




==> ../../mimestring.mli <==
(* $Id: mimestring.mli,v 1.8 2000/08/13 00:04:36 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)

(**********************************************************************)
(* Collection of auxiliary functions to parse MIME headers            *)



==> ../../netbuffer.ml <==
(* $Id: netbuffer.ml,v 1.3 2000/06/25 22:34:43 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)

type t =
    { mutable buffer : string;



==> ../../netbuffer.mli <==
(* $Id: netbuffer.mli,v 1.3 2000/06/25 22:34:43 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)


(* A Netbuffer.t is a buffer that can grow and shrink dynamically. *)



==> ../../netencoding.ml <==
(* $Id: netencoding.ml,v 1.5 2000/06/25 22:34:43 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)


module Str = Netstring_str;;



==> ../../netencoding.mli <==
(* $Id: netencoding.mli,v 1.4 2000/06/25 22:34:43 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)

(**********************************************************************)
(* Several encodings important for the net                            *)



==> ../../netstream.ml <==
(* $Id: netstream.ml,v 1.2 2000/06/24 20:20:33 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)


type t =



==> ../../netstream.mli <==
(* $Id: netstream.mli,v 1.2 2000/06/24 20:20:33 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)


(* A netstream is an input channel that is read block by block. The



==> ../../netstring_str.ml <==
(* $Id: netstring_str.ml,v 1.2 2000/06/25 21:15:48 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)

let lock   = ref (fun () -> ());;
let unlock = ref (fun () -> ());;



==> ../../netstring_str.mli <==
(* $Id: netstring_str.mli,v 1.2 2000/06/25 21:15:48 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)

(* This module is a version of Str with a thread-safe interface *)




==> ../../neturl.ml <==
(* $Id: neturl.ml,v 1.4 2000/07/04 21:50:51 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)

exception Malformed_URL




==> ../../neturl.mli <==
(* $Id: neturl.mli,v 1.3 2000/06/26 22:57:49 gerd Exp $
 * ----------------------------------------------------------------------
 *
 *)

(* This module applies already O'Caml-3 features. *)




==> ../../parse_rupinfo.ml <==

(*
ce fichier qui devra etre un module qui exportera
la fonction make_host_pref_objet qui renvoi un objet
de type Rup_op.host_pref
*)




==> ../../parse_rupinfo.mli <==
(* module type PARSE_RUPINFO =
  sig  *)

type 'a t = Rup_op.host_pref
val make_host_pref_objet : unit -> Rup_op.host_pref
val make_host_pref_objet2 : in_channel -> Rup_op.host_pref
val pp_host_pref : Rup_op.host_pref -> unit



==> ../../parse_ruppref.ml <==
open Rup_op;;

exception Not_an_ruppref of string;;
exception Not_a_tp of string;;
exception Not_an_action of string;;
exception Not_a_latency;;
exception Not_an_rup_x_pref of string;;



==> ../../proto_rup.ml <==
module Rupproto =
    struct
      type t = Rup_op.host_pref
      let of_channel =  Parse_rupinfo.make_host_pref_objet2
      let to_string = Rup_op.to_string_host_pref
    end;;




==> ../../protocol.mli <==
module type PROTOCOL =
    sig
      type t = Rup_op.host_pref
      val of_channel : in_channel -> t
      val to_string : t -> string
    end;;




==> ../../rup_cgi.ml <==
(* rup_cgi.ml, robot serveur rup, supporte le protocole HTTP via CGI.
   Prend en charge les (robots-)clients rup supportant le protocole HTTP.
   
   A installer dans le repertoire cgi-bin/ d'un serveur Web (teste sur Apache),
   l'addresse du service est alors : http://machine.domaine/cgi-bin/rup_cgi

*)



==> ../../rup_op.ml <==
(*
   fichier rup_op.ml
   Definitions for OCaml types intended to build RUP objects,
   from RUP specification.
   Definir des types OCaml a partir de la specification RUP.
   Definir des methodes to_string et of_string pour ces objets...
*)



==> ../../rupd.ml <==
(*
   Ce processus execute apres la generation des indexes (tout les MinimumLatency) s'occupe de :
    - Collecter les informations destinees a chaque robot, les stocker dans le fichier du robot.
    - Consulter le fichier ruprobots.txt afin de determiner a qui et comment envoyer l'information, si besoin.
   En gros : Pour chaque robot (de bd_ruppref) faire :
    - ajouter ce qu'il filtre dans son fichier de nom id_du_robot
    - verifier si c'est le moment d'envoyer auquel cas envoyer conformement aux indications

Sources C

 -- le programme rupstat_s.c --
Permet de generer un index au format txt.

J'ai essaye de faire quelquechose de rapide, efficace, maniable et portable
(je l'ai fait tourner sur un Macintosh...).

Ce programme peut etre facilement modifie afin de generer l'index
sous divers formats (xml, sql, html, ...).

Sources Shell/Utils

 -- diff, sed et autres... --
rupd_script.sh

Une fois l'index genere par rupstat il faut extraire l'information
desiree (ie : les listes des fichiers modifies, effaces, nouveaux).

Cette tache est accomplie par un script shell qui fait appel au commandes
UNIX diff, grep, awk et sed ) apres avoir lui meme lance le programme rupstat.

Ainsi c'est ce script qui 'centralise' tout ce qui concerne l'indexation,
ce qui est tres pratique lorsque nous le lancons avec crond.