Constructors

XML::Compile::Transport->new(%options)

 -Option --Default
  address  'http://localhost'
  charset  'UTF-8'
    

WSDL11

$obj->wsdl11Init($wsdl, $args)

XML::Compile::Transport->wsdl11Init($wsdl, $args)

Inherited, see "WSDL11" in XML::Compile::SOAP::Extension

SOAP11

$obj->soap11ClientWrapper($operation, $call, $args)

Inherited, see "SOAP11" in XML::Compile::SOAP::Extension

$obj->soap11HandlerWrapper($operation, $callback, $args)

Inherited, see "SOAP11" in XML::Compile::SOAP::Extension

$obj->soap11OperationInit($operation, $args)

XML::Compile::Transport->soap11OperationInit($operation, $args)

Inherited, see "SOAP11" in XML::Compile::SOAP::Extension

SOAP12

$obj->soap12ClientWrapper($operation, $call, $args)

Inherited, see "SOAP12" in XML::Compile::SOAP::Extension

$obj->soap12HandlerWrapper($operation, $callback, $args)

Inherited, see "SOAP12" in XML::Compile::SOAP::Extension

$obj->soap12OperationInit($operation, $args)

XML::Compile::Transport->soap12OperationInit($operation, $args)

Inherited, see "SOAP12" in XML::Compile::SOAP::Extension

Accessors

$obj->address()

Get a server address to contact. If multiple addresses were specified, than one is chosen at random.

$obj->addresses()

Returns a list of all server contact addresses (URIs)

$obj->charset()

Returns the charset to be used when sending,

Handlers

$obj->compileClient(%options)

Compile a client handler. Returned is a subroutine which is called with a text represenation of the XML request, or an XML::LibXML tree. In SCALAR context, an XML::LibXML parsed tree of the answer message is returned. In LIST context, that answer is followed by a HASH which contains trace information.

 -Option    --Default
  hook        <undef>
  kind        'request-response'
  xml_format  0
    

Use of the transport hook

There are two reasons to use a hook:

.

You want to fake a server, to produce a test environment.

.

You may need to modify the request or answer messages outside the reach of XML::Compile::SOAP, because something is wrong in either your WSDL of XML::Compile message processing.

XML and Header Modifications

Some servers require special extensions, which do not follow any standard (or logic). But even those features can be tricked, although it requires quite some programming skills.

The "transport_hook" routine is called with a $trace hash, one of whose entries is the UserAgent which was set up for the data transfer. You can modify the outgoing message XML body and headers, carry out the data exchange using the UserAgent, and then examine the returned Response for content and headers using methods similar to the following:

 sub transport_hook($$$)
 {   my ($request, $trace, $transporter) = @_;
     my $content = $request->content;

     # ... modify content if you need
     my $new_content = encode "UTF-8", $anything;
     $request->content($new_content);
     $request->header(Content_Length => length $new_content);
     $request->header(Content_Type => 'text/plain; charset=UTF-8');

     # ... update the headers
     $request->header(Name => "value");

     # sent the request myself
     my $ua = $trace->{user_agent};
     my $response = $ua->request($request);

     # ... check the response headers
     my $name = $response->header('Name');

     # ... use the response content
     my $received = $response->decoded_content || $response->content;

     $response;
 }

You should be aware that if you change the size or length of the content you MUST update the "Content-Length" header value, as demonstrated above.

Transport hook for debugging

The transport hook is a perfect means for producing automated tests. Also, the XML::Compile::SOAP module tests use it extensively. It works like this (for the SOAPHTTP simluation):

 use Test::More;

 sub fake_server($$)
 {  my ($request, $trace) = @_;
    my $content = $request->decoded_content;
    is($content, <<__EXPECTED_CONTENT);
<SOAP-ENV:Envelope>...</SOAP-ENV:Envelope>
__EXPECTED_CONTENT

    HTTP::Response->new(200, 'Constant'
      , [ 'Content-Type' => 'text/xml' ]
      , <<__ANSWER
<SOAP-ENV:Envelope>...</SOAP-ENV:Envelope>
__ANSWER
 }

Then, the fake server is initiated in one of the follow ways:

  my $transport = XML::Compile::Transport::SOAPHTTP->new(...);
  my $http = $transport->compileClient(hook => \&fake_server, ...);
  $wsdl->compileClient('GetLastTracePrice', transporter => $http);

or

  my $soap = XML::Compile::SOAP11::Client->new(...);
  my $call = $soap->compileClient(encode => ..., decode => ...,
      transport_hook => \&fake_server);

or

  my $wsdl = XML::Compile::WSDL11->new(...);
  $wsdl->compileClient('GetLastTracePrice',
      transport_hook => \&fake_server);

Transport hook for basic authentication

[Adapted from an example contributed by Kieron Johnson] This example shows a transport_hook for compileClient() to add to http headers for the basic http authentication. The parameter can also be used for compileAll() and many other related functions.

  my $call = $wsdl->compileClient($operation
     , transport_hook => \&basic_auth );

  # HTTP basic authentication encodes the username and password with
  # Base64. The encoded source string has format: "username:password"
  # With the below HTTP header being required:
  #        "Authorization: Basic [encoded password]"

  use MIME::Base64 'encode_base64';

  my $user     = 'myuserid' ;
  my $password = 'mypassword';

  sub basic_auth($$)
  {   my ($request, $trace) = @_;

      # Encode userid and password
      my $authorization = 'Basic '. encode_base64 "$user:$password";

      # Modify http header to include basic authorisation
      $request->header(Authorization => $authorization );

      my $ua = $trace->{user_agent};
      $ua->request($request);
  }