Cours gratuits » Cours informatique » Cours développement web » Cours Rebol » Cours Développement d’applications distribuées avec Rebol IOS

Cours Développement d’applications distribuées avec Rebol IOS


Télécharger



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Cours Développement d’applications distribuées avec Rebol

...

Présentation de Rebol/IOS

Internet Operating System,

Solution flexible de groupware,

Serveur d’applications et de documents,

Echange et partage d’informations,

IOS n’est pas une solution clé en main.

Serveur et clie

nt

IOS est composé de deux éléments :

Le serveur Rebol/Express,

Le client Rebol/Link

Disponibles pour plusieurs systèmes d’exploitation

Solution légère

Le serveur Express

Accès aux bases de données,

Chiffrement,

Shell,

Port system,

SSL,

Protocole RMP

Le client Link

Bureau virtuel,

Synchronisation,

Personnalisation de l’aspect graphique,

Gestion d’un cache sur le poste local,

Travail en mode connecté ou off-line.

Connexion de Link à Express

Connexion directe à l’aide du protocole RMP (Intranet),

Connexion au serveur Express par l’intermédiaire d’un proxy dédié

(Internet).

Les reblets livrées avec IOS

Communiquer,

Partager des informations et des données,

Gérer les fichiers,

Administrer le serveur.

Les atouts de la solution IOS

Administration centralisée,

Déploiement automatique des applications.

Sécurisation totale des échanges

Identification des utilisateurs,

Client dédié au serveur,

Echange de données cryptées.

Gestion transparente des sessions et de la synchronisation des données,

Applications fonctionnant en local et invoquant des méthodes distantes,

Réactivité de l’interface utilisateur.

Gérer les documents avec les filesets

Eléments fondamentaux de l’architecture de Rebol/IOS,

Regroupements de fichiers dont les règles d’accessibilité sont identiques,

Pour être synchronisable, un fichier doit appartenir à un fileset,

Les propriétés d’un fileset sont spécifiées à l’aide des tags.

Les principaux tags

Install-date

Version

Users (utilisateurs ayant accès au fileset)

Groups (groupes ayant accès au fileset)

Folders (répertoire sur le bureau de Link)

Icons

Services

Priority (degrès de priorité lors de la synchronisation)

Access (privilèges d’accès)

Propriétés du tag Access

Change

Delete

Post

Server-code

Rights

Properties

Desktop

Folders

Icons

Trois types d’application

Script publié,

Script Rebol synchronisé comme un simple document.

Reblet pout Link (type: ‘app-link)

Exploite l’API cliente de Link.

Application IOS (type: ‘app-link)

Exploite les API du client Link et du serveur

Express.

Installation d’une Reblet ou d’un application IOS

Le programmeur ne travaille jamais sur le serveur Express,

Link permet de publier l’application

(CTRL + L),

Utilisation de deux fichiers :

Description du fileset et du code serveur de l’application à l’aide du mot install-fileset,

Script client.

Les fonctions clientes de Link

Des nouveaux mots pour :

Obtenir des informations sur le client,

Gérer les tâches.

Un dialecte d’administration utilisant

deux méthodes de communication:

Synchrone pour get-link,

Asynchrone pour send-link.

Les nouveaux mots de Link

Informations sur le client:

Connected?

Link-root

User-prefs

Gestion des tâches:

Start-app

Stop-app

Les commandes de get-link

Fileset

App-tags

App-reg

File-reg

Client

Users-prefs

Servers

Serve-keys

User-accounts

Tâches

App-id

Apps

Apps-instances

Sessions

Session-id

Unique-id

Les commandes de send-link

Reboot

Relance du client Link

Keep-alive

Maintient d’une connexion persistente

Get

Liste des fichiers présents dans un fileset

Download

Téléchargement par le client d’un fichier non synchronisé

La gestion des événements

Un événement est associé à un fileset ou à l’ensemble des filesets,

La détection d’un événement déclenche l’appel d’une fonction,

Déclaration d’un événement:

Insert-notify

Supression d’un événement:

Remove-notify

Exemple de gestionnaire d’événement

On-get: func [ event data ] [ remove-notify ‘get none

Print mold data

]

Insert-notify ‘get none :on-get

Send-link ‘get ‘app-files ‘documents

Les extensions du serveur Express

Link accède au dialecte d’administration du serveur Express à l’aide du mot send-server,

Des méthodes distantes peuvent être définies par le programmeur (post),

Express dispose d’une puissante API serveur.

Les commandes de send-server

Comptes utilisateurs

User-info

Users

New-user

Change-user

Change-password

Add-group

Remove-group

Delete-user

Test du serveur

Ping noop

Envoi de fichiers

Add-file

Base de registres

New-app

Change-tags

Delete-app

Les principaux événements

File-downloaded

Download

Add-file

Get get

Status ping

Users

Users

User-info

User-info

Serve-done

New-user

Delete-user

Change-password

Change-user

Add-group

Remove-group

New-app

Change-tags

Delete-app

noop

Définir une méthode post

Répartition du travail entre le client et le serveur,

Le code exécuté par le serveur est stocké dans un fileset,

Les variables spécifiques à la méthode post sont déclaré à l’aide du mot post-locals,

Les données transmises par le client sont récupérées à l’aide du mot message,

La commande ‘post déclenche un événement

post-reply.

L’API serveur d’Express

Dictionnaire de Rebol/Express

Manipulation des filesets

Administration des comptes utilisateurs

Gestion des fichiers

Manipulation des filesets

New-app

App-data-name

Load-app

Change-tags

Add-file

Delete-app

Administrer les comptes utilisateurs

New-user

Change-user

Add-user-to-group

Remove-user-from-group

Delete-user

Serve-total-users

Get-users

Get-user-info

Gestion des fichiers

Write-data

Load-data

Read-data

Size-data?

Data-exists?

… … …

Les blocs

Rebol, en tant que langage dynamique, vous permet de manipuler des blocs de code qui peuvent être exécutés quand bon vous semble. Mais ces blocs sont aussi la principale structure de données, et pourront également vous servir à contenir des données diverses.

Les blocs sont des conteneurs

Construire des blocs

Nous en avons un tout petit peu parlé précédemment. Les blocs servent à contenir des objets Rebol comme des chaînes, des nombres ou autres (pourquoi pas d'autres blocs ?), tous rangés dans un certain ordre. On écrit le bloc avec des crochets, en séparant les objets par un espace. Par exemple foo: [1 2 3 4] stocke un bloc contenant ces 4 chiffres dans la variable foo.

Il existe plusieurs fonctions pour manipuler les blocs, dont les plus simples sont empty? et length?. La première fonction renvoie true quand son argument est un bloc vide, la seconde renvoie la longueur de son argument quand c'est un bloc :

>> empty? []

== true

>> empty? [foo]

== false

>> length? foo    ; notre variable foo: [1 2 3 4]

== 4

>> length? [a b [foo bar]]    ; Notez que le mot bar n'a pas besoin d'être défini ; nous y reviendrons.

== 3

Naturellement, il nous faut aussi des fonctions pour construire des blocs (qui seront par exemple utilisées dans des boucles ou des fonctions comme nous le verrons prochainement). La fonction la plus élémentaire pour ça est la fonction append. Elle prend en argument un bloc et une valeur à ajouter. Par exemple :

>> append [1 2 3] 4

== [1 2 3 4]

Cependant, observez l'exemple suivant :

>> append [1 2 3] [unbloc]

== [1 2 3 unbloc]

Voici un comportement singulier. Quand nous utilisons append sur deux blocs, la fonction ajoute le contenu du deuxième au premier. Mais si nous voulions ajouter le bloc [unbloc] comme élément du premier ?

Il faut utiliser ce que l'on appelle un raffinement. Les raffinements sont des options que l'on peut passer à certaines fonctions. Ici, append peut recevoir le raffinement /only, ce qui donne

>> append/only [1 2 3] [unbloc]

== [1 2 3 [unbloc]]

Bien sûr dans les cas précédents, append continue d'avoir le même comportement. Nous utiliserons cette particularité lorsque nous voudrons construire des blocs de blocs.

Cela ne s'est pas vu ici, mais la fonction append modifie les blocs sur lesquels elle travaille. En d'autres termes, si nous écrivons append unbloc unevaleur, le bloc unbloc est modifié, append ne se contente pas de renvoyer le résultat.

Altérer des blocs déjà existant

Une autre fonction intéressante est insert. Cette fonction prend en argument un bloc et une valeur et modifie ce bloc pour insérer le résultat au début. Voici des exemples :

>> insert [1 2 3] 0

== [1 2 3]

>> foo: [1 2 3]

== [1 2 3]

>> insert foo 0

== [1 2 3]

>> print foo

0 1 2 3

Il est important que vous compreniez qu'ici, ce qui compte ça n'est pas le résultat de insert, qu'on pourrait à la limite ignorer. Ce qui compte, c'est la modification que cette fonction réalise sur le bloc.

Pour modifier une valeur dans un bloc, utilisez replace bloc valeur1 valeur2. Pour supprimer une valeur, utilisez remove bloc (supprime l'élément en tête). Un petit exemple vaut mieux qu'un long discours :

>> foo: [1 1 3 1 1]

== [1 1 3 1 1]

>> replace foo 1 2

== [2 1 3 1 1]

>> replace/all foo 1 2

== [2 2 3 2 2]

>> foo

== [2 2 3 2 2]

>> remove foo

== [2 3 2 2]

>> foo

== [2 3 2 2]

>> remove/part foo length? foo

== []

Notez le raffinement replace/all qui remplacera les valeurs dans le bloc entier (sans ce raffinement seule la première valeur qui correspond à ce que l'on cherche est remplacée). Notez également le raffinement remove/part qui ajoute un argument : le nombre d'éléments à supprimer. Ici, on passe en argument length? foo soit le nombre d'éléments total contenu dans le bloc.

Une question d'index

Les blocs sont particulièrement importants en Rebol. Si vous connaissez le langage Lisp, ils ont autant d'importance que les listes dans ce langage. Toutefois, les blocs Rebol possèdent une caractéristique importante que les listes n'ont pas : ils contiennent un index interne, qui sert à faire des opérations.

C'est une notion qui se révèlera utile, comme toutes les autres, mais qui est pleine de pièges. On peut voir cet index comme une sorte de curseur qui indique où l'on est en train de travailler, sans pour autant détruire le bloc. En quelques sortes, on "cache" une partie du bloc pour faire des opérations sur le reste. Cependant, on peut récupérer à tout moment le bloc original, en profitant des modifications qui on été réalisées.

La seule fonction que nous présenterons pour l'instant est next, qui permet d'avancer d'un cran le curseur dans un bloc. Il en existe d'autres comme back et skip, au sujet desquelles je vous invite à vous renseigner, en tapant help back dans la ligne de commande Rebol par exemple.

La fonction next va en fait renvoyer le bloc privé de son premier élément (sauf si le bloc est vide bien sûr), et il faut alors le stocker dans une variable (éventuellement la même) ou réaliser des opérations directement dessus. Par exemple :

>> foo: [1 2 3 4 5]

== [1 2 3 4 5]

>> foo: next next foo

== [3 4 5]

>> foo

== [3 4 5]

À ce stade on dirait que foo a été modifiée de façon irréversible? On peut stocker une nouvelle valeur dans cette "nouvelle" variable foo, par exemple :

>> insert foo 0

== [3 4 5]

>> foo

== [0 3 4 5]

Mais, à l'aide de la fonction head, nous pouvons alors afficher le bloc depuis le début (ce qui ne déplace pas le curseur, cela produit juste un affichage) :

>> head foo

== [1 2 0 3 4 5]

Surprise ! Ni le 1 ni le 2 n'ont été perdus, ils étaient simplement mis de côté pendant que nous travaillions plus loin dans le bloc? Nous reviendrons sur les index lorsque nous utiliserons des boucles pour modifier des blocs de données.

Des blocs de code

Outre le fait qu'ils contiennent des données, les blocs en Rebol servent surtout à contenir? du code ! Rebol permet en effet de manipuler du code, et d'utiliser certaines fonctions sur les blocs pour exécuter ce code dans un contexte particulier. Si vous n'avez utilisé pour le moment que des langages de bas niveau, cela peut vous sembler étrange et contre nature.

Pourtant, cela peut se montrer très utile. On a alors la possibilité d'écrire des fonctions (dites "d'ordre supérieur") qui manipulent ce code pour le faire s'exécuter dans des contextes particuliers. Imaginons que vous commandiez un robot : vous pourrez alors définir une fonction d'évaluation des commandes du robot qui reconnaît, en plus des mots habituels, des instructions pour que le robot avance, recule, tourne? Vous écririez par exemple

robot [


50