Appel de WebServices Soap en Ruby
Soap, on aime ou on aime pas. Je pense que Soap sur HTTP, c’est dommage, autant utiliser le protocole http correctement et proposer des services web en RESTful . Comme je l’ai lu quelque part, c’est comme “mettre une enveloppe dans une enveloppe”. Toujours est-il que ça a quand même le mérite d’exister . Et nous nous sommes retrouvé à devoir faire appel à un webservice SOAP en ruby, j’aimerais vous faire part de la façon dont on a réalisé cela.
Après avoir jeté un coup d’oeil à soap4r nous avons voulu regarder ce qui existait déjà, et là, surprise, soap4r est intégré à la librairie standard de Ruby avec une base très riche pour l’utilisation de Soap et quelques outils bien pratique pour l’utilisation des fichiers WSDL.
Du coup, il ne reste plus qu’a générer les classes qui s’occuperont de l’appel “soap” à l’aide de l’objet WSDL2Ruby.
Pour cette génération, nous avons repris un script wsdl2ruby.rb trouvé dans les repertoires du Trac du projet soap4r (qui date un peu). En gros il ajoute quelque explication sur l’utilisation de la ligne de commande permettant de générer les classes Soap, et permet d’enchainer l’envoie du message run après avoir mis en place la location et placé quelque options bien choisi.
Voici LA méthode principale du wsdl2ruby.rb:
{% highlight ruby %}
def run
@worker = WSDL::SOAP::WSDL2Ruby.new
@worker.logger = @log
location, opt = parse_opt(GetoptLong.new(*OptSet))
usage_exit unless location
@worker.location = location
if opt['quiet']
self.level = Logger::FATAL
else
self.level = Logger::INFO
end
@worker.opt.update(opt)
@worker.run
0
end
{% endhighlight %}
En executant donc cette commande wsdl2ruby.rb --wsdl '[l'adresse du fichier wsdl de mon service soap qui tue]' --type client
Il existe pas mal d’option pour créer un webservice, mais ici nous voulions créer un client pour appeler un webservice soap existant.
Cette commande nous a donc générer deux fichiers: default.rb et defaultDriver.rb. Ce dernier s’occuper de la connexion au service, et défini les methodes que l’on peut utiliser ainsi que les paramètres qui vont bien avec. Le fichier default contient lui un objet par methode du service. Dans notre cas, nous avion un objet qui correspond à l’appel, et un pour la réponse. Bien sur, avant d’intégrer ce code généré, il faudrais faire un petit renomage, mais ça vous savez faire.
Notre service permet
Le defaultDriver.rb généré.
{% highlight ruby %}
require 'default.rb'
require 'soap/rpc/driver'
class Authentification < ::SOAP::RPC::Driver
DefaultEndpointUrl = "http://example.com:8080/axis/services/authentification"
MappingRegistry = ::SOAP::Mapping::Registry.new
Methods = [
[ "",
"authentification",
[ ["in", "parameters", ["::SOAP::SOAPElement", "http://auth.example.com/", "authentification"], true],
["out", "parameters", ["::SOAP::SOAPElement", "http://auth.example.com/", "response"], true] ],
{ :request_style => :document, :request_use => :literal, :response_style => :document, :response_use => :literal }
]
]
def initialize(endpoint_url = nil)
endpoint_url ||= DefaultEndpointUrl
super(endpoint_url, nil)
self.mapping_registry = MappingRegistry
init_methods
end
private
def init_methods
Methods.each do |definitions|
opt = definitions.last
if opt[:request_style] == :document
add_document_operation(*definitions)
else
add_rpc_operation(*definitions)
qname = definitions[0]
name = definitions[2]
if qname.name != name and qname.name.capitalize == name.capitalize
::SOAP::Mapping.define_singleton_method(self, qname.name) do |*arg|
__send__(name, *arg)
end
end
end
end
end
end
{% endhighlight %}
Le fichier généré default.rb
{% highlight ruby %}
require 'xsd/qname'
class Authentification
@@schema_type = "authentification"
@@schema_ns = "http://auth.example.com"
@@schema_qualified = "true"
@@schema_element = [["login", "SOAP::SOAPString"], ["pwd", "SOAP::SOAPString"]]
attr_accessor :login
attr_accessor :pwd
def initialize(login = nil, pwd = nil)
@login = login
@pwd = pwd
end
end
class Response
@@schema_type = "response"
@@schema_ns = "http://auth.example.com/"
@@schema_qualified = "true"
@@schema_element = [["result", "SOAP::SOAPString"]]
attr_accessor :result
def initialize(result = nil)
@result = result
end
end
{% endhighlight %}
Du coup, il ne reste plus qu’a créer un nouvelle objet proxy (qui porte le nom du service et que l’on retrouve dans le fichier defaultDriver.rb), puis d’envoyer les messages qui vont bien avec les paramètres.
{% highlight ruby %}
require 'defaultDriver'
auth_proxy = Authentification.new
response = auth_proxy.authentification(:login => 'james', :pwd => 'bond')
puts response.result
{% endhighlight %}
Au final, ça fonctionne plutôt bien et c’est en peut de temps que l’on a pu mettre en place cet appel. Soap est un protocole de communication verbeux, mais il a l’avantage d’être très bien intégré dans les divers langages et framework, et, dans notre cas, nous avons plusieurs technologie qui utilise ce service. On préfèrerais bien sur voir ici l’utilisation d’un service rest mais il faudrais dans ce cas que les autres technologie soit capable de l’utiliser, et pour certaine techno un peu vieillissante, c’est pas facile (de plus reprendre le code existant a un coût).
Je n’aime pas non plus le code généré pour plusieurs raison dont le manque de test. On sent aussi qu’avec les capacités dynamique de Ruby on pourrais ne pas générer du code, mais construire à la volé les appels au service soap.