NAME

XML::Compile::WSDL11 - create SOAP messages defined by WSDL 1.1

INHERITANCE

XML::Compile::WSDL11
  is a XML::Compile::Cache
  is a XML::Compile::Schema
  is a XML::Compile

SYNOPSIS

# preparation
use XML::Compile::WSDL11;      # use WSDL version 1.1
use XML::Compile::SOAP11;      # use SOAP version 1.1
use XML::Compile::Transport::SOAPHTTP;

my $wsdl = XML::Compile::WSDL11->new($wsdlfile);
$wsdl->addWSDL(...more WSDL files...);
$wsdl->importDefinitions(...more schemas...);

# during initiation, for each used call (slow)
my $call = $wsdl->compileClient('GetStockPrice', ...);

# at "run-time", call as often as you want (fast)
my $answer = $call->(%request);

# capture useful trace information
my ($answer, $trace) = $call->(%request);

# no need to administer the operations by hand: alternative
$wsdl->compileCalls;  # at initiation
my $answer = $wsdl->call(GetStockPrice => %request);

# investigate the %request structure (server input)
print $wsdl->explain('GetStockPrice', PERL => 'INPUT');

# investigate the $answer structure (server output)
print $wsdl->explain('GetStockPrice', PERL => 'OUTPUT');

# when you like, get all operation definitions
my @all_ops = $wsdl->operations;

# Install XML::Compile::SOAP::Daemon
my $server  = XML::Compile::SOAP::HTTPDaemon->new;
$server->operationsFromWSDL($wsdl);
undef $wsdl;    # not needed any further

# For debug info, start your script with:
use Log::Report mode => 'DEBUG';

DESCRIPTION

This module implements WSDL version 1.1. An WSDL file defines a set of messages to be send and received over (SOAP) connections.

As end-user, you do not have to worry about the complex details of the messages and the way to exchange them: it's all simple Perl for you. Also, faults are handled automatically. The only complication you have to worry about is to shape a nested HASH structure to the sending message structure. XML::Compile::Schema::template() may help you.

When the definitions are spread over multiple files you will need to use addWSDL() (wsdl) or importDefinitions() (additional schema's) explicitly. Usually, interreferences between those files are broken. Often they reference over networks (you should never trust). So, on purpose you must explicitly load the files you need from local disk! (of course, it is simple to find one-liners as work-arounds, but I will to tell you how!)

METHODS

Constructors

XML::Compile::WSDL11->new(XML, OPTIONS)

The XML is the WSDL file, which is anything accepted by XML::Compile::dataToXML().

-Option            --Defined in     --Default
 allow_undeclared    XML::Compile::Cache  <false>
 any_element         XML::Compile::Cache  'SKIP_ALL'
 block_namespace     XML::Compile::Schema  []
 hook                XML::Compile::Schema  undef
 hooks               XML::Compile::Schema  []
 ignore_unused_tags  XML::Compile::Schema  <false>
 key_rewrite         XML::Compile::Schema  []
 opts_readers        XML::Compile::Cache  []
 opts_rw             XML::Compile::Cache  []
 opts_writers        XML::Compile::Cache  []
 prefixes            XML::Compile::Cache  <smart>
 schema_dirs         XML::Compile     undef
 typemap             XML::Compile::Cache  {}
 xsi_type            XML::Compile::Cache  {}

allow_undeclared => BOOLEAN
any_element => CODE|'TAKE_ALL'|'SKIP_ALL'|'ATTEMPT'|'SLOPPY'
block_namespace => NAMESPACE|TYPE|HASH|CODE|ARRAY
hook => ARRAY-WITH-HOOKDATA | HOOK
hooks => ARRAY-OF-HOOK
ignore_unused_tags => BOOLEAN|REGEXP
key_rewrite => HASH|CODE|ARRAY-of-HASH-and-CODE
opts_readers => HASH|ARRAY-of-PAIRS
opts_rw => HASH|ARRAY-of-PAIRS
opts_writers => HASH|ARRAY-of-PAIRS
prefixes => HASH|ARRAY-of-PAIRS
schema_dirs => DIRECTORY|ARRAY-OF-DIRECTORIES
typemap => HASH|ARRAY
xsi_type => HASH|ARRAY

Accessors

$obj->addHook(HOOKDATA|HOOK|undef): See "Accessors" in XML::Compile::Schema
$obj->addHooks(HOOK, [HOOK, ...]): See "Accessors" in XML::Compile::Schema
$obj->addKeyRewrite(PREDEF|CODE|HASH, ...): See "Accessors" in XML::Compile::Schema
$obj->addSchemaDirs(DIRECTORIES|FILENAME)
XML::Compile::WSDL11->addSchemaDirs(DIRECTORIES|FILENAME): See "Accessors" in XML::Compile
$obj->addSchemas(XML, OPTIONS): See "Accessors" in XML::Compile::Schema
$obj->addTypemap(PAIR): See "Accessors" in XML::Compile::Schema
$obj->addTypemaps(PAIRS): See "Accessors" in XML::Compile::Schema
$obj->allowUndeclared([BOOLEAN]): See "Accessors" in XML::Compile::Cache
$obj->blockNamespace(NAMESPACE|TYPE|HASH|CODE|ARRAY): See "Accessors" in XML::Compile::Schema
$obj->hooks: See "Accessors" in XML::Compile::Schema
$obj->prefix(PREFIX): See "Accessors" in XML::Compile::Cache
$obj->prefixFor(URI): See "Accessors" in XML::Compile::Cache
$obj->prefixed(TYPE): See "Accessors" in XML::Compile::Cache
$obj->prefixes([PAIRS|ARRAY|HASH]): See "Accessors" in XML::Compile::Cache
$obj->typemap([HASH|ARRAY|PAIRS]): See "Accessors" in XML::Compile::Cache
$obj->useSchema(SCHEMA, [SCHEMA]): See "Accessors" in XML::Compile::Schema
$obj->xsiType([HASH|ARRAY|LIST]): See "Accessors" in XML::Compile::Cache

Compilers

$obj->call(OPERATION, DATA)

[2.20] Call the OPERATION (by name) with DATA (HASH or LIST of parameters). This only works when you have called compileCalls() beforehand, always during the initiation phase of the program.

example:

# at initiation time (compile once)
$wsdl->compileCalls;

# at runtime (run often)
my $answer = $wsdl->call($operation, $request);

$obj->compile(('READER'|'WRITER'), TYPE, OPTIONS)

See "Compilers" in XML::Compile::Schema

$obj->compileAll(['READERS'|'WRITERS'|'RW'|'CALLS', [NAMESPACE]])

[2.20] With explicit CALLS or without any parameter, it will call compileCalls(). Otherwise, see XML::Compile::Cache::compileAll().

$obj->compileCalls(OPTIONS)

[2.20] Compile a handler for each of the available operations. The OPTIONS are passed to each call of compileClient(), but will be overruled by more specific declared options.

Additionally, OPTIONS can contain service, port, and binding to limit the set of involved calls. See operations() for details on these options.

You may declare additional specific compilation options with the declare() method.

example:

my $trans = XML::Compile::Transport::SOAPHTTP
  ->new(timeout => 500, address => $wsdl->endPoint);
$wsdl->compileCalls(transport => $trans);

# alternatives for simple cases
$wsdl->compileAll('CALLS');
$wsdl->compileAll;

my $answer = $wsdl->call($myop, $request);

See "Compilers" in XML::Compile

$obj->reader(TYPE|NAME, OPTIONS)

See "Compilers" in XML::Compile::Cache

$obj->template('XML'|'PERL', ELEMENT, OPTIONS)

See "Compilers" in XML::Compile::Schema

$obj->writer(TYPE|NAME)

See "Compilers" in XML::Compile::Cache

Extension

$obj->addWSDL(XMLDATA)

The XMLDATA must be acceptable to XML::Compile::dataToXML() and should represent the top-level of a (partial) WSDL document. The specification can be spread over multiple files, each of which must have a definition root element.

$obj->compileClient([NAME], OPTIONS)

Creates an XML::Compile::SOAP::Operation temporary object using operation(), and then calls compileClient() on that.

The OPTIONS available include all of the options for:

.: operation() (i.e. service and port), and all of
.: XML::Compile::SOAP::Operation::compileClient() (there are many of these, for instance transport_hook and server)

You cannot pass options for XML::Compile::Schema::compile(), like <sloppy_integers = 0>>, hooks or typemaps this way. Use new(opts_rw) and friends to declare those.

example:

$wsdl->compileClient
  ( operation => 'HelloWorld'
  , port      => 'PrefillSoap' # only needed when multiple ports
  );

$obj->namesFor(CLASS)

Returns the list of names available for a certain definition CLASS in the WSDL. See index() for a way to determine the available CLASS information.

$obj->operation([NAME], OPTIONS)

Collect all information for a certain operation. Returned is an XML::Compile::SOAP::Operation object.

An operation is defined by a service name, a port, some bindings, and an operation name, which can be specified explicitly and is often left-out: in the many configurations where there are no alternative choices. In case there are alternatives, you will be requested to pick an option.

-Option   --Default
 action     <undef>
 operation  <required>
 port       <only when just one port in WSDL>
 service    <only when just one service in WSDL>

action => STRING: Overrule the soapAction from the WSDL.
operation => NAME: Ignored when the parameter list starts with a NAME (which is an alternative for this option). Optional when there is only one operation defined within the portType.
port => NAME: Required when more than one port is defined.
service => QNAME|PREFIXED: Required when more than one service is defined.

Administration

$obj->declare(GROUP, COMPONENT|ARRAY, OPTIONS)

Register specific compile OPTIONS for the specific COMPONENT. See also XML::Compile::Cache::declare(). The GROUP is either READER, WRITER, RW (both reader and writer), or OPERATION. As COMPONENT, you specify the element name (for readers and writers) or operation name (for operations). OPTIONS are specified as LIST, ARRAY or HASH.

example:

$wsdl->declare(OPERATION => 'GetStockPrice', @extra_opts);
$wsdl->compileCalls;
my $answer = $wsdl->call(GetStockPrice => %request);

$obj->doesExtend(EXTTYPE, BASETYPE)

See "Administration" in XML::Compile::Schema

$obj->elements

See "Administration" in XML::Compile::Schema

$obj->findName(NAME)

See "Administration" in XML::Compile::Cache

$obj->findSchemaFile(FILENAME)

XML::Compile::WSDL11->findSchemaFile(FILENAME)

See "Administration" in XML::Compile

$obj->importDefinitions(XMLDATA, OPTIONS)

See "Administration" in XML::Compile::Schema

$obj->knownNamespace(NAMESPACE|PAIRS)

XML::Compile::WSDL11->knownNamespace(NAMESPACE|PAIRS)

See "Administration" in XML::Compile

$obj->namespaces

See "Administration" in XML::Compile::Schema

$obj->types

See "Administration" in XML::Compile::Schema

$obj->walkTree(NODE, CODE)

See "Administration" in XML::Compile

Introspection

All of the following methods are usually NOT meant for end-users. End-users should stick to the operation() and compileClient() methods.

$obj->endPoint(OPTIONS)

[2.20] Returns the address of the server, as specified by the WSDL. When there are no alternatives for service or port, you not not need to specify those paramters.

-Option --Default
 port     <undef>
 service  <undef>

port => NAME
service => QNAME|PREFIXED

$obj->explain(OPERATION, FORMAT, DIRECTION, OPTIONS)

[2.13] Produce templates (see XML::Compile::Schema::template() which detail the use of the OPERATION. Currently, only the PERL template FORMAT is available.

The DIRECTION of operation is either INPUT (input for the server, hence to be produced by the client), or OUTPUT (from the server, received by the client).

The actual work is done by XML::Compile::SOAP::Operation::explain(). The OPTIONS passed to that method include recurse and skip_header.

example:

print $wsdl->explain('CheckStatus', PERL => 'INPUT');

$obj->findDef(CLASS, [QNAME|PREFIXED|NAME])

With a QNAME, the HASH which contains the parsed XML information from the WSDL template for that CLASS-NAME combination is returned. You may also have a PREFIXED name, using one of the predefined namespace abbreviations. Otherwise, NAME is considered to be the localName in that class. When the NAME is not found, an error is produced.

Without QNAME in SCALAR context, there may only be one such name defined otherwise an error is produced. In LIST context, all definitions in CLASS are returned.

example:

$service  = $obj->findDef(service => 'http://xyz');
@services = $obj->findDef('service');

$obj->index([CLASS, [QNAME]])

With a CLASS and QNAME, it returns one WSDL definition HASH or undef. Returns the index for the CLASS group of names as HASH. When no CLASS is specified, a HASH of HASHes is returned with the CLASSes on the top-level.

CLASS includes service, binding, portType, and message.

$obj->operations(OPTIONS)

Return a list with all operations defined in the WSDL.

-Option --Default
 binding  <undef>
 port     <undef>
 service  <undef>

binding => NAME: Only return operations which use the binding with the specified NAME. By default, all bindings are accepted.
port => NAME: Return only operations related to the specified port NAME. By default operations from all ports.
service => NAME: Only return operations related to the NAMEd service, by default all services.

$obj->printIndex([FILEHANDLE], OPTIONS)

For available OPTIONS, see operations(). This method is useful to understand the structure of your WSDL: it shows a nested list of services, bindings, ports and portTypes.

-Option       --Defined in         --Default
 show_declared  XML::Compile::Cache  <true>

show_declared => BOOLEAN

DETAILS

Comparison

Collecting definitions

Organizing your definitions

Addressing components

Representing data-structures

simpleType

complexType/simpleContent

complexType and complexType/complexContent

Manually produced XML NODE

Occurence

Default Values

Repetative blocks

repetative sequence, choice, all

repetative groups

repetative substitutionGroups

List type

Using substitutionGroup constructs

Wildcards any and anyAttribute

ComplexType with "mixed" attribute

hexBinary and base64Binary

Schema hooks

defining hooks

general syntax

hooks on matching types

hooks on matching ids

hooks on matching paths

Typemaps

Private variables in objects

Typemap limitations

Handling xsi:type

Key rewrite

key_rewrite via table

rewrite via function

key_rewrite when localNames collide

rewrite for convenience

pre-defined key_rewrite rules

Initializing SOAP operations via WSDL

When you have a WSDL file, then SOAP is simple. If there is no such file at hand, then it is still possible to use SOAP. See the DETAILS chapter in XML::Compile::SOAP.

The WSDL file contains operations which can be addressed by name. In the WSDL file you need to find the name of the port to be used. In most cases, the WSDL has only one service, one port, one binding, and one portType and those names can therefore be omitted. If there is a choice, then you must explicitly select one.

use XML::Compile::WSDL11 ();

# once in your program
my $wsdl   = XML::Compile::WSDL11->new('def.wsdl');

# XML::Compile::Schema refuses to follow "include" and
# "import" commands, so you need to invoke them explicitly.
# $wsdl->addWSDL('file2.wsdl');            # optional
# $wsdl->importDefinitions('schema1.xsd'); # optional

# once for each of the defined operations
my $call   = $wsdl->compileClient('GetStockPrice');

# see XML::Compile::SOAP chapter DETAILS about call params
my $answer = $call->(%request);

LICENSE

Copyrights 2007-2011 by Mark Overmeer. For other contributors see ChangeLog.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See http://www.perl.com/perl/misc/Artistic.html

To install XML::Compile::SOAP, copy and paste the appropriate command in to your terminal.

cpanm

cpanm XML::Compile::SOAP

CPAN shell

perl -MCPAN -e shell
install XML::Compile::SOAP

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

INHERITANCE

SYNOPSIS

DESCRIPTION

METHODS

Constructors

Accessors

Compilers

Extension

Administration

Introspection

DETAILS

Comparison

Collecting definitions

Organizing your definitions

Addressing components

Representing data-structures

simpleType

complexType/simpleContent

complexType and complexType/complexContent

Manually produced XML NODE

Occurence

Default Values

Repetative blocks

repetative sequence, choice, all

repetative groups

repetative substitutionGroups

List type

Using substitutionGroup constructs

Wildcards any and anyAttribute

ComplexType with "mixed" attribute

hexBinary and base64Binary

Schema hooks

defining hooks

general syntax

hooks on matching types

hooks on matching ids

hooks on matching paths

Typemaps

Private variables in objects

Typemap limitations

Handling xsi:type

Key rewrite

key_rewrite via table

rewrite via function

key_rewrite when localNames collide

rewrite for convenience

pre-defined key_rewrite rules

Initializing SOAP operations via WSDL

SEE ALSO

LICENSE

Module Install Instructions