Jolie, un langage de programmation orienté services,

Il permet d'agréger directement les API de services dans un serveur Web

Le 20 mai 2021 à 16:35, par Bruno

156PARTAGES

Lancé en 2006 dans le cadre de ses études à l'Université de Bologne par Fabrizio Montesi, Jolie (Java Orchestration Language Interpreter Engine) est un langage de programmation open source pour le développement d'applications distribuées basées sur des microservices. Dans le paradigme de programmation proposé avec Jolie, chaque programme est un service qui peut communiquer avec d'autres programmes en envoyant et en recevant des messages sur un réseau. Jolie prend en charge une couche d'abstraction qui permet aux services de communiquer en utilisant différents supports, allant des sockets TCP/IP aux communications locales en mémoire entre les processus.

Jolie est actuellement pris en charge par un interpréteur implémenté dans le langage Java, qui peut être exécuté dans plusieurs systèmes d'exploitation, notamment les systèmes d'exploitation basés sur Linux, OS X et Windows. Le langage est doté d'une sémantique formelle, ce qui signifie que l'exécution des programmes Jolie est définie mathématiquement. Pour cette raison, Jolie est utilisé dans la recherche pour l'étude de techniques basées sur le langage pour le développement de systèmes distribués, et il est également utilisé pour l'enseignement dans certaines universités.

Si les qualités de Jolie en font un langage prisé dans le domaine de la recherche, notamment pour l'étude des techniques basées sur le langage pour le développement des services et systèmes distribués, il n’en est pas moins vrai que le langage n’est pas accepté par toute la communauté des développeurs. Au sein de cette communauté, certains professionnels du développement estiment que le langage qui cristallise les concepts de programmation de l'informatique orientée services sous forme de constructions linguistiques n’est qu’un langage de trop. Si l'on en croit du moins la réaction de cet internaute lors d’une discussion sur Jolie.

« Qui veut réellement cela ? Les gens veulent de bonnes bibliothèques pour faire cela avec les langages qu'ils utilisent déjà, et non pas avoir à faire des compromis juste pour avoir un microservice. Remarquez que la page d'accueil donne de nombreux exemples des parties du code relatives aux services, mais absolument aucun exemple de ce à quoi ressemble la logique métier. En fait, même dans la documentation, le code d'exemple est minimal et trivial ».
Pour un autre internaute, le langage est une autre forme de framework et, sans surprise, il a été développé en Java pour les utilisateurs de Java.

« Je pense que cela peut devenir populaire pour les fans de frameworks Java. Entre eux, les gens peuvent se chamailler à propos de J2EE, Spring ou Quarkus, ou Oracle Fusion, Microprofile et une myriade d'autres. Mais l'idée centrale est que toute personne utilisant directement Java avec l'aide de librairies standard et tierces est un vieux fossile qui devrait être éliminé du projet/de l'entreprise ou, mieux encore, de la main-d'œuvre tout entière ».

S’il est établi que Jolie ne fait pas l’unanimité, il convient de mentionner que le concept même du langage intéresse plus d’une personne. « Je le veux. Au moins l'idée. Je veux quelque chose qui ressemble à un langage de programmation (les plus courants) qui décrit et spécifie le flux d'une fonctionnalité, pas un YAML ou un fichu fichier XML, mais pas non plus un framework XYZ qui contient tous les détails de mise en œuvre. Peut-être que Jolie n'est pas ce que je veux et qu'il a plus de bagages que ce dont je suis actuellement conscient, mais il ressemble d'une certaine manière à quelque chose dont j'ai besoin », déclare Pedro Batista, un développeur Web. Voici, ci-dessous, quelques caractéristiques du langage Jolie :

Penser en termes de services

Jolie cristallise les concepts de programmation de l'informatique orientée services sous forme de constructions linguistiques. Les éléments de base des logiciels ne sont pas des objets ou des fonctions, mais plutôt des services qui peuvent être déplacés et répliqués selon les besoins. Une composition de services est un service.

Code :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
type HelloRequest {
	name:string
}

interface HelloInterface {
requestResponse:
	hello( HelloRequest )( string )
}

service HelloService {
	execution: concurrent

	inputPort HelloService {
		location: "socket://localhost:9000"
		protocol: http { format = "json" }
		interfaces: HelloInterface
	}

	main {
		hello( request )( response ) { 
			response = "Hello " + request.name
		}
	}
}

Adapté aux microservices et aux API

Jolie est un langage de programmation axé sur les contrats, qui place la conception des API au premier plan. Il prend en charge les communications synchrones et asynchrones. Les modèles de données sont définis par des types qui supportent le raffinement (en rouge dans le code ci-dessous), et les transformations DTO (Data Transfer Objects) sont gérées de manière transparente par l'interpréteur.

Code :

Sélectionner tout

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
type GetProfileRequestType {
	id:int
}
type GetProfileResponseType {
	name:string
	surname:string
	email:string( regex(".*@.*\\..*") )
	accounts[0,*] {
		nickname:string
		service_url:string
		enabled:bool
	}
	ranking:int( ranges( [1,5] ) )
}

type SendMessageRequestType {
	id:int
	message:string( length( [0,250] ) )
}

interface ProfileInterface {
requestResponse: // Synchronous RPC
	getProfile( GetProfileRequestType )( GetProfileResponseType )

oneWay: // Asynchronous
	sendMessage( SendMessageRequestType )
}

Conçu pour l'ère du réseau

Le code de Jolie est toujours contenu dans des services, que vous pouvez toujours faire passer de local à distant et vice-versa, sans altérer la logique de vos programmes. Une application monolithique peut être distribuée par conception : si vous décidez d'en distribuer une partie, il suffit de la prendre et de l'exécuter sur une autre machine.

Protocole agnostique

Jolie est agnostique en termes de protocoles : vos services peuvent échanger des données en utilisant différents protocoles. Le pontage de deux réseaux utilisant des protocoles différents est une question de quelques lignes de code. Si vous avez besoin d'un protocole que Jolie ne prend pas encore en charge, il existe une API pour en développer de nouveaux en Java.

Code :

Sélectionner tout

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
type HelloRequest {
	name:string
}

interface HelloInterface {
requestResponse:
	hello( HelloRequest )( string )
}

service HelloService {
	execution { concurrent }

	inputPort HelloServiceHTTP {
		location: "socket://localost:9000"
		protocol: http { format = "json" }
		interfaces: HelloInterface
	}

	inputPort HelloServiceSOAP {
		location: "socket://localost:9001"
		protocol: soap { 
			wsdl = "myWsdl.wsdl" 
			wsdl.port = "MyServiceSOAPPort"
		}
		interfaces: HelloInterface
	}

	inputPort HelloServiceSODEP {
		location: "socket://localost:9002"
		protocol: sodep 
		interfaces: HelloInterface
	}

	main {
		// This can now be reached through HTTP/JSON, SOAP, or SODEP (binary)
		hello( request )( response ) { 
			response = "Hello " + request.name
		}
	}
}

Flux de travail structurés

Jolie est livré avec des primitives natives pour structurer les flux de travail, par exemple en séquences (l'une après l'autre) ou en parallèle (aller en même temps). Cela permet au code de suivre naturellement les exigences, en évitant les variables comptables sujettes aux erreurs pour vérifier ce qui s'est passé jusqu'à présent dans un calcul. Par exemple, le code suivant indique que les opérations publish et edit deviennent disponibles en même temps (|), mais seulement après ( l'invocation de l'opération login.

Code :

Sélectionner tout

1
2
login( credentials )() { checkCredentials };
{ publish( x ) | edit( y ) }

Gestion dynamique des erreurs pour le code parallèle

La programmation d'un code parallèle fiable est un défi, car les fautes peuvent provoquer des effets secondaires dans les activités parallèles. Jolie est livré avec une sémantique solide pour la gestion des fautes parallèles. Les programmeurs peuvent mettre à jour le comportement des gestionnaires de fautes au moment de l'exécution, en suivant l'exécution des activités grâce à la primitive install

Code :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
include "console.iol"
include "time.iol"

main
{
    scope( grandFather )
    {
        install( this => println@Console( "recovering grandFather" )() );
        scope( father )
        {
            install( this => println@Console( "recovering father" )() );
            scope ( son )
            {
                install( this => println@Console( "recovering son" )() );
                sleep@Time( 500 )();
                println@Console( "Son's code block" )()
            }
        }
    }
    |
    throw( a_fault )
}

Jolie offre de nombreuses possibilités pour construire des logiciels complexes à partir de services simples. Même l'architecture de déploiement d'un système peut être programmée avec des primitives natives, généralisant les pratiques communes. Tout ce que vous construisez est à nouveau un service que vous pouvez exposer ; ainsi, il peut être réutilisé pour construire à nouveau ! Voici quelques exemples de composition :

orchestration : un orchestrateur est un service qui offre des fonctionnalités obtenues en coordonnant d'autres services avec un flux de travail ;
agrégation : une généralisation des proxies et des équilibreurs de charge, que vous pouvez utiliser pour composer et exposer les API de services distincts ;
redirection : une généralisation des serveurs virtuels, qui masque l'emplacement réel des services aux clients en leur attribuant des noms logiques ;
intégration : une généralisation des serveurs d'application, qui exécute d'autres services en tant que composants internes. Elle permet des communications locales rapides et peut même exécuter du code écrit dans d'autres langages que Jolie, comme Java et JavaScript.

Jolie permet de programmer directement un serveur web qui est juste un service comme tout le reste dans Jolie. Vous n'avez pas besoin d'autres frameworks supplémentaires pour instancier un serveur web. Il est possible d'agréger directement d'autres API de services dans un serveur web Jolie, ainsi les interfaces graphiques web sont complètement indépendantes du système de microservices avec lequel elles interagissent. Le langage supporte nativement JSON, XML, AJAX, GWT, et d'autres technologies.

Source : Jolie

Et vous ?