Free soap software for linux

SOAP::WSDL is a Perl module.

SYNOPSIS

use SOAP::WSDL;

my $soap=SOAP::WSDL->new( wsdl => http://server.com/ws.wsdl )
->proxy( http://myurl.com);

$soap->wsdlinit;

my $som=$soap->call( method => [
{ name => value },
{ name => value } ]);

SOAP::WSDL provides decent WSDL support for SOAP::Lite. It is built as a add-on to SOAP::Lite, and will sit on top of it, forwarding all the actual request-response to SOAP::Lite - somewhat like a pre-processor.

WSDL support means that you dont have to deal with those bitchy namespaces some web services set on each and every method call parameter.

It also means an end to that nasty

SOAP::Data->name( Name )->value(
SOAP::Data->name( Sub-Name)->value( Subvalue )
);

encoding of complex data. (Another solution for this problem is just iterating recursively over your data. But that doesnt work if you need more information [e.g. namespaces etc] than just your data to encode your parameters).

And it means that you can use ordinary hashes for your parameters - the encording order will be derived from the WSDL and not from your (unordered) data, thus the problem of unordered perl-hashes and WSDL >sequence< definitions is solved, too. (Another solution for the ordering problem is tying your hash to a class that provides ordered hashes - Tie::IxHash is one of them).

SOAP::Data is a Perl class that provides the means by which to explicitly manipulate and control all aspects of the way in which Perl data gets expressed as SOAP data entities.

The SOAP::Data class provides the means by which to explicitly manipulate and control all aspects of the way in which Perl data gets expressed as SOAP data entities. Most of the methods are accessors, which like those in SOAP::Lite are designed to return the current value if no new one is passed, while returning the object reference otherwise (allowing for chained method calls). Note that most accessors (except value) accept a new value for the data object as a second argument.

METHODS

new(optional key/value pairs)
$obj = SOAP::Data->new(name => idx, value => 5);

This is the class constructor. Almost all of the attributes related to the class may be passed to the constructor as key/value pairs. This method isnt often used directly because SOAP::Data objects are generally created for temporary use. It is available for those situations that require it.

name(new name, optional value)
$obj->name(index);

Gets or sets the current value of the name, as the object regards it. The name is what the serializer will use for the tag when generating the XML for this object. It is what will become the accessor for the data element. Optionally, the objects value may be updated if passed as a second argument.

type(new type, optional value)
$obj->type(int);

Gets or sets the type associated with the current value in the object. This is useful for those cases where the SOAP::Data object is used to explicitly specify the type of data that would otherwise be interpreted as a different type completely (such as perceiving the string 123 as an integer, instead). Allows the setting of the objects value, if passed as a second argument to the method.

uri(new uri, optional value)
$obj->uri(http://www.perl.com/SOAP);

Gets or sets the URI that will be used as the namespace for the resulting XML entity, if one is desired. This doesnt set the label for the namespace. If one isnt provided by means of the prefix method, one is generated automatically when needed. Also allows the setting of the objects value, if passed as a second argument to the method.

prefix(new prefix, optional value)
$obj->prefix(perl);

Provides the prefix, or label, for use when associating the data object with a specific namespace. Also allows the setting of the objects value, if passed as a second argument to the method.

attr(hash reference of attributes, optional value)
$obj->attr({ attr1 => value });

Allows for the setting of arbitrary attributes on the data object. Keep in mind the requirement that any attributes not natively known to SOAP must be namespace-qualified. Also allows the setting of the objects value, if passed as a second argument to the method.

value(new value)
$obj->value(10);

Fetches the current value encapsulated by the object, or explicitly sets it.
The last four methods are convenience shortcuts for the attributes that SOAP itself supports. Each also permits inclusion of a new value, as an optional second argument.

actor(new actor, optional value)
$obj->actor($new_actor_name);

Gets or sets the value of the actor attribute; useful only when the object generates an entity for the message header.

mustUnderstand(boolean, optional value)
$obj->mustUnderstand(0);

Manipulates the mustUnderstand attribute, which tells the SOAP processor whether it is required to understand the entity in question.

encodingStyle(new encoding URN, optional value)
$obj->encodingStyle($soap_11_encoding);

This method is most likely to be used in places outside the header creation. Sets encodingStyle, which specifies an encoding that differs from the one that would otherwise be defaulted to.

root(boolean, optional value)
$obj->root(1);

When the application must explicitly specify which data element is to be regarded as the root element for the sake of generating the object model, this method provides the access to the root attribute.

SOAP::XML::Client is a simple frame work for talking with web services.

This package is the base class for talking with web services, there are specific modules to use depending on the type of service you are calling, e.g. SOAP::XML::Client::DotNet or SOAP::XML::Client::Generic

This package helps in talking with web services, it just needs a bit of XML thrown at it and you get some XML back. Its designed to be REALLY simple to use.

SOAP::Amazon::S3 is a Perl module for interfacing with Amazon S3 through SOAP.

SYNOPSIS

An object-oriented interface to handle your Amazon S3 storage. (Still experimental, although functional)

use SOAP::Amazon::S3;

my $s3 = SOAP::Amazon::S3->new( $access_key_id, $secret_access_key, { Debug => 1, RaiseError => 1 } );

my @buckets = $s3->listbuckets;
my $bucket = $s3->createbucket(mybucketname);
my $bucket = $s3->bucket(myoldbucket); # wont create a new bucket

print $bucket->name;
$bucket->delete;

my @objects = $bucket->list;
my $object = $bucket->putobject( $obj_key, $obj_data, { Content-Type => text/plain } );
my $object = $bucket->object( $old_obj_key ); # wont put a new object in the bucket

print $object->name;
$object->delete;
$object->acl(public);
$object->acl(private);
print $object->acl(); # will print public or private

$data = $object->getdata;

FUNCTIONS

SOAP::Amazon::S3->new( $access_key_id, $secret_key_id, { Debug => 0_or_1, RaiseError => 0_or_1 } );

Creates a new S3 requester object. The {} parameters are optional and default to 0. Debug will output all SOAP communications on screen. RaiseError will make your program die if it receives an error reply from Amazon S3, and output the error message on screen. If RaiseError is off, then $s3->{error} will still be set to true when an S3 error occurs.

Asterisk-Soap is an extensible SOAP (Web services) API with the goal to create and support all Asterisk configuration features.

Asterisk Soap APIs mainly feature is to provide a framework between asterisk core api and multi-platform frontends.

SOAP::XML::Client::DotNet is a Perl module to talk with .net webservices.

This package helps in talking with .net servers, it just needs a bit of XML thrown at it and you get some XML back. Its designed to be REALLY simple to use.

You dont need to know this, but the major difference to SOAP::XML::Client::Generic is it will submit as:

SOAPAction: "http://www.yourdomain.com/services/GetSellerActivity"

and does not put in namesp< X >

Java GForge SOAP Interface (or JaGoSI for short) is an approach to access the GForge collaboration platform via Java. This can be used to put other applications on top of JaGoSI. It may be integrated with other applications like the former MyLar project.
Enhancements:
- A complete working file distribution is available for the GForge platform via an Ant task.
- Many bugs were fixed.
- The Maven build was fixed, so compiling with sub components is working.
- The project structure was changed.
- JUnit was updated to version 4.