SEIFE:: WSDL ist eine Perl-Baugruppe.

SYNOPSE

Gebrauch SEIFE:: WSDL;

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

$soap->wsdlinit;

mein $som=$soap->call (Methode => [
{Namens=> Wert},
{Namens=> Wert}]);

SEIFE:: WSDL gewährt annehmbaren WSDL Träger für SEIFE:: Lite. Er aufgebaut als Zusatzhardware er, um EINZUSEIFEN:: Lite und sitzt oben auf es und nachschickt die ganze tatsächliche Fordernantwort zur SEIFE: e: Lite - ein wenig wie ein Präprozessor.

WSDL Träger bedeutet, dass Sie nicht jene gehässigen namespaces beschäftigen müssen, die irgendeines Webs Dienstleistungen auf jeden Methodenaufrufparameter einstellen.

Er bedeutet auch ein Ende zu bösem dem

SEIFE:: Data->name (Name) - >value (
SEIFE:: Data->name (Vor-Name) - >value (Subvalue)
);

kodierung der komplizierten Daten. (Eine andere Lösung für dieses Problem wiederholt gerade rekursiv über Ihren Daten. Aber das arbeitet nicht, wenn Sie mehr Informationen [z.B. namespaces usw.] als gerade Ihre Daten benötigen, Ihre Parameter zu kodieren).

Und es bedeutet, dass Sie Üblichen verwenden können hacken für Ihre Parameter - die encording Ordnung berechnet vom WSDL und nicht von Ihren (ungeordneten) Daten, so Perl-hackt das Problem von ungeordnetem und WSDL >sequence< Definitionen gelöst, auch. (Eine andere Lösung für das bestellenproblem bindet Ihr Durcheinander an einer Kategorie, die bestellt hackt zur Verfügung stellt - Gleichheit:: IxHash ist einer von ihnen).

SEIFE:: Lite ist eine Klienten- und Serverseite SEIFEN-Umsetzung.

SEIFE:: Lite ist eine Ansammlung Perl-Baugruppee, die eine einfache und leichte Schnittstelle zum einfachen Nachrichten-Zugriffs-Protokoll (SOAP)auf Klienten- und Serverseite zur Verfügung stellt.

Sind hier einige Hauptmerkmale „der seife Lite“:

· Träger EINSEIFEN spezielles 1.1 .1.
· Interoperabilitätsprüfungen mit verschiedenen Umsetzungen: Apache-SEIFE, Apache-Schwerpunkt, Grenze, Microsoft EINSEIFEN, Microsoft .NET, DevelopMentor, XMethods, 4s4c, Phalanx, PocketSOAP, Kafka, SQLData, Lucin ta (in Java, Perl, C++, Pythonschlange, VB, COM, XSLT).
· Zur Verfügung stellt COM-Schnittstelle. Einzelnes DLL (unabhängig [2.5MB] oder minimal [32kB]). Arbeiten über Windows 9x/Me/NT/2K. Erfordert nicht SEIL oder MSXML. Beispiele in VB, in Excel/VBA, in C#, in Asp, im Javascript, in PerlScript und in Perl.
· Gewährt transparenten Komprimierungträger für HTTP-Transport.
· Zur Verfügung stellt mod_soap Baugruppe. SEIFEN-Server mit einigen Leitungen .htaccess oder .conf in der Datei herstellen.
· Enthält XML:: Syntaxanalyse:: Lite (regexp-gegründete XML Syntaxanalyse) der anstelle von XML: läuft: Syntaxanalyse, wo Perl 5.6 (sogar auf WinCE) mit etwas Beschränkungen läuft.
· Enthält XMLRPC:: Lite, Umsetzung des XML-RPC Protokolls auf Klienten und Serverseite. Alle Transporte und Merkmale der SEIFE:: Lite sind erhältlich.
· Unterstützt die Mehrfach-/Formulardaten MIME-Befestigungen.
· Stützverkettete Kreislisten und mehrfache Hinweise.
· Stützkarte datatype (kodierung der Karten/hackt mit willkürlichen Schlüsseln).
· Protokoll der Unterstützungs HTTPS.
· Gewährt Vollmachtträger.
· Zur Verfügung stellt CGI/daemon/mod_perl/Apache:: Registerserverumsetzungen.
· Zur Verfügung stellt TCP-Serverumsetzung.
· Zur Verfügung stellt Serverumsetzung IO-(STDIN/STDOUT/File).
· Zur Verfügung stellt ftp-Klientenumsetzung.
· Träger aussondern te,/Mehrfach-MIME-Befestigung (nur analysierenseite).
· Unterstützungs-smtp-Protokoll.
· Zur Verfügung stellt Umsetzung des Servers POP3.
· Träger M-POST und umadressiert im HTTP-Transport t.
· Träger Authentisierung des grundlegenden/Auswahlservers.
· Arbeiten mit cgi-Beschleunigern, wie VelociGen und PerlEx.
· Schnittstelle der Unterstützungs UDDI auf Klientenseite. UDDI sehen:: Lite für Sonderkommandos.
· Träger UDDI, die API veröffentlichen. Beispiele und Unterlagen bereitgestellt.
· Schema der Unterstützungs WSDL mit Stummel und Ablaufzugriff.
· Träger gesegnete Nachrichtenhinweise.
· Stützreihen (periodische Veröffentlichung und deserialization mit dem Mittels Autotypie vervielfältigen).
· Unterstützt kundenspezifische periodische Veröffentlichung.
· Versieht Ausnahmetransport mit kundenspezifischen Ausnahmen
· Kodierung der Unterstützungs Base64.
· Körperschaftkodierung der Unterstützungs XML.
· Stützvorsatzattribute.
· Träger dynamisch und statische Kategorien-/Methodenschwergängigkeit.
· Unterstützungsc$nachricht-durchhinweis mit einfacher Abfallansammlung und -aktivierung.
· Zur Verfügung stellt Shell für interaktive SEIFEN-Sitzungen.
· Stützheraus Parameterbinden.
· Unterstützungstransparente SEIFEN-Aufrufe mit autodispatch Merkmal.
· Zur Verfügung stellt einfache Service-Dislozierung. Baugruppe in spezifiziertes Verzeichnis einsetzen und itll ist zugänglich.
· Hat Prüfungen, Beispiele und die Unterlagen, zum Sie in keiner Zeit unternehmungslustig sein zu lassen.

SEIFE:: Daten:: ComplexType ist eine abstrakte Kategorie für das Herstellen und das Handhaben der komplizierten SEIFE:: Datenobjekte.

SYNOPSE

mein verpacken:: SEIFE:: Daten:: ComplexType:: Foo;
strenges verwenden;
Vorsichtshinweise verwenden;
Gebrauch SEIFE:: Daten:: ComplexType;
vars qw (@ISA) verwenden;
@ISA = qw (SEIFE:: Daten:: ComplexType);

konstantes OBJ_URI => http://foo.bar.baz verwenden;
konstantes OBJ_TYPE => ns1 verwenden: myFoo;
konstantes OBJ_FIELDS => verwenden {
=> field1 [Zeichenkette, undef, undef],
=> field2 [int, undef, undef],
=> field3 [xsd: Datum/Uhrzeit, undef, undef]
};

Vorneue {
mein $proto = Schiebung;
mein $class = Hinweis ($proto) || $proto;
mein $data = Schiebung;
mein $obj_fields = Schiebung;
$obj_fields = definierte $obj_fields && Hinweis ($obj_fields) eq DURCHEINANDER? {% {+OBJ_FIELDS}, % {$obj_fields}}: OBJ_FIELDS;
mein $self = $class->SUPER:: neu ($data, $obj_fields);
zurückgehen segnen ($self, $class);
}

mein verpacken:: SEIFE:: Daten:: ComplexType:: Rechtsanwaltschaft;
strenges verwenden;
Vorsichtshinweise verwenden;
Gebrauch SEIFE:: Daten:: ComplexType;
vars qw (@ISA) verwenden;
@ISA = qw (SEIFE:: Daten:: ComplexType);

konstantes OBJ_URI => http://bar.baz.uri verwenden;
konstantes OBJ_TYPE => ns1 verwenden: myBar;
konstantes OBJ_FIELDS => verwenden {
=> val1 [Zeichenkette, undef, undef],
=> val2 [
[
Mein:: SEIFE:: Daten:: ComplexType:: Foo:: OBJ_TYPE,
Mein:: SEIFE:: Daten:: ComplexType:: Foo:: OBJ_FIELDS
],
Mein:: SEIFE:: Daten:: ComplexType:: Foo:: OBJ_URI, undef
]
};

Vorneues {
mein $proto = Schiebung;
mein $class = Hinweis ($proto) || $proto;
mein $data = Schiebung;
mein $obj_fields = Schiebung;
$obj_fields = definiertes $obj_fields && Hinweis ($obj_fields) eq DURCHEINANDER? {% {+OBJ_FIELDS}, % {$obj_fields}}: OBJ_FIELDS;
mein $self = $class->SUPER:: neu ($data, $obj_fields);
zurückgehen segnen ($self, $class);
}

########################################################################
Pakethauptleitung;

mein $request_obj = mein:: SEIFE:: Daten:: ComplexType:: Bar->new ({
=> val1 sometext,
=> val2 {
=> field1 moretext,
field2 => 12345,
field3 => 2005-10-26T12: 00: 00.000Z
}
});
Druck $request_obj->as_xml_data;

Gebrauch SEIFE:: Lite;
mein $result = SEIFE:: Lite
- >uri ($uri)
- >proxy ($proxy)
- >somemethod (SEIFE:: Data->value ($request_obj->as_soap_data))
- >result;

das #assuming die Methode zurückbringt eine Nachricht des Typen Foo… ringt
wenn (Hinweis ($result) eq Foo) {
mein $result_obj = mein:: SEIFE:: Daten:: ComplexType:: Foo->new ($result);
Druck „$_=“. $result_obj->$_. „N“ foreach befestigt % {+My:: SEIFE:: Daten:: ComplexType:: Foo:: OBJ_FIELDS};
}

AUSZUG

SEIFE:: Daten:: ComplexType definiert eine strukturierte Schnittstelle, um Kategorien zu implementieren, die unendlich komplizierte SEIFE: darstellen: Datenobjekte. Nachrichtenfälle können komplizierte seife dynamisch festlegen:: Datenstrukturen oder reines XML, wie gebraucht. Bereiche einer Nachricht können leicht erreicht werden, indem man einen Methodenaufruf mit Namen des Bereichs als die Methode bildet, und Bereichwerte können nach Nachrichtenaufbau durch die Anwendung der gleichen Methode mit einem Parameter geändert werden.

Gesegnete Nachrichten zurückgingen durch eine SEIFE: gen: Lite-Methoden SEIFE:: SOM->result kann verwendet werden, um die Nachricht zurück in ein gleichwertiges ComplexType wieder herzustellen und Mängel der seife so lösen:: Lites Handhaben der komplizierten Typen und Erlauben Benutzern, auf ihre Nachrichten auf eine viel abstraktere und intuive Art zurückzugreifen. Dieses ist auch für Anwendungen außergewöhnlich nützlich, die Gebrauch SEIFEN-Resultatsnachrichten in den zukünftigen SEIFEN-Aufrufen benötigen.

BESCHREIBUNG

Diese Baugruppe soll sie viel einfacher bilden, komplizierte seife herzustellen:: Datenobjekte in einer objektorientierten Kategoriezelle, als Benutzern der SEIFE:: Lite muß SEIFEN-Datenstrukturen aktuell manuell in Handarbeit machen. Er verwendet SEIFE:: Daten:: Erbauer innerlich, zum von Nachrichtendaten zu lagern und festzulegen.
Ich hoffe, daß diese Baugruppe erheblich Produktivität jeder möglicher SEIFE: verbessert: Lite-Programmierer, besonders die, die viele komplizierten datatypes beschäftigen oder mit seife apps arbeiten, die Erbschaft implementieren.

Kwiki:: SEIFE:: Google ist ein Experiment mit SEIFEN-Antrag zu Google durch wafl.

SYNOPSE

{googlesoap meine Rechercheausdrücke}

Dieses ist eine WAFL Phrase für Kwiki, das Recherchen von google durch ihre seife API erlaubt. Sie müssen Ihren eigenen Google API Schlüssel haben, zum es zu verwenden. Wenn Sie nicht ein haben, können Sie ein von Google erhalten:

http://www.google.com/apis/

Nach Einbau müssen Sie das Kwiki bearbeiten:: SEIFE:: Google Datei, zum Ihres Schlüssels hinzuzufügen (dieses verbessert zu einer neueren Zeit).

SEIFE:: Amazonas:: S3 ist eine Perl-Baugruppe für die Zusammenschaltung an Amazonas S3 durch SEIFE.

SYNOPSE

Eine objektorientierte Schnittstelle, zum Ihres Speichers Amazonas-S3 zu handhaben. (Noch experimentell, obgleich funktionell)

Gebrauch SEIFE:: Amazonas:: S3;

mein $s3 = SEIFE:: Amazonas:: S3->new ($access_key_id, $secret_access_key, {=> 1, RaiseError => 1 ausprüfen},);

meine @buckets = $s3->listbuckets;
mein $bucket = $s3->createbucket (mybucketname);
mein $bucket = $s3->bucket (myoldbucket); # stellt nicht eine neue Wanne her

Druck $bucket->name;
$bucket->delete;

meine @objects = $bucket->list;
mein $object = $bucket->putobject ($obj_key, $obj_data, {Inhalt-Typ => Text/normales});
mein $object = $bucket->object ($old_obj_key); # setzt eine neue Nachricht nicht in die Wanne ein

Druck $object->name;
$object->delete;
$object->acl (Öffentlichkeit);
$object->acl (privat);
Druck $object->acl (); # druckt allgemeines oder privates

$data = $object->getdata;

FUNKTIONEN

SEIFE:: Amazonas:: S3->new ($access_key_id, $secret_key_id, {=> 0_or_1, RaiseError => 0_or_1 ausprüfen},);

Erstellt eine neue Nachricht des Bittstellers S3. Die {} Parameter sind wahlweise und Zahlungseinstellung bis 0. Ausprüfen ausgibt alle SEIFEN-Kommunikationen auf Siebanlage. RaiseError läßt Ihr Programm sterben, wenn es eine Fehlerantwort von Amazonas S3 empfängt, und gab die Fehlermeldung auf Siebanlage aus. Wenn RaiseError aus ist, dann wird $s3-> {Fehler} noch eingestellt, um auszurichten, wann ein Fehler S3 auftritt.

SEIFE:: XML:: Klient ist eine einfache Rahmenarbeit für die Unterhaltung mit Web-Dienstleistungen.

Dieses Paket ist die falsche Kategorie für die Unterhaltung mit Web-Dienstleistungen, dort sind die spezifischen abhängig von dem Typen des Services zu verwenden Baugruppee, den Sie rufen, z.B. SEIFE:: XML:: Klient:: DotNet oder SEIFE:: XML:: Klient:: Generisch

Dieses Paket hilft bei der Unterhaltung mit Web-Dienstleistungen, benötigt es gerade ein Bit von XML geworfen an ihm und Sie erhalten irgendein XML rückseitig. Sein konzipiert, um WIRKLICH einfach zu sein zu verwenden.

SEIFE:: Daten sind eine Perl-Kategorie, die die Mittelwerte liefert, durch die, alle Aspekte der Methode ausdrücklich zu manipulieren und zu steuern, in der Perl-Daten erhalten, als SEIFEN-Datenkörperschaften ausdrückten.

Die SEIFE:: Datenkategorie liefert die Mittelwerte, durch die, alle Aspekte der Methode ausdrücklich zu manipulieren und zu steuern, in der Perl-Daten erhalten, als SEIFEN-Datenkörperschaften ausdrückten. Die meisten Methoden sind Accessors, die wie die in der SEIFE:: Lite konzipiert, um den aktuellen Wert zurückzubringen, wenn kein Neues geführt, beim den Nachrichtenhinweis anders zurückbringen (zulassend verkettete Methodenaufrufe). Notiert, dass die meisten Accessors (ausgenommen Wert) einen neuen Wert für das Datenobjekt als zweites Argument annehmen.

METHODEN

neu (wahlweise Schlüssel-/Wertpaare)
$obj = SEIFE:: Data->new (Namens=> idx, Wert => 5);

Dieses ist der Kategorienerbauer. Fast alle Attribute in Verbindung standen auf der Kategorie können als Schlüssel-/Wertpaare passiert werden dem Erbauer. Diese Methode ist nicht direkt häufig benutzt, weil SEIFE:: Datenobjekte erstellt im Allgemeinen für temporären Gebrauch. Er ist für jene Situationen erhältlich, die ihn erfordern.

Name (neuer Name, wahlweisewert)
$obj->name (Anzeigemarke);

Erhält oder einstellt den aktuellen Wert des Namens n, da die Nachricht ihn betrachtet. Der Name ist, was der Serializer für die Marke verwendet, wenn es das XML für diese Nachricht festlegt. Es ist, was der Accessor für das Datenelement wird. Wahlweise kann der Nachrichtenwert aktualisiert sein, wenn er als zweites Argument passiert.

schreiben (neuer Typ, wahlweisewert)
$obj->type (int);

Erhält oder einstellt den Typen verbunden mit dem aktuellen Wert in der Nachricht n. Dieses ist für jene Fälle nützlich, wo die SEIFE:: Datenobjekt verwendet, um den Typen von Daten ausdrücklich zu spezifizieren, die anders als anderer Typ vollständig geübersetzt (wie Empfinden der Zeichenkette 123 als ganze Zahl, stattdessen). Erlaubt die Einstellung des Nachrichtenwertes, wenn Sie als zweites Argument zur Methode passiert.

uri (neues uri, wahlweisewert)
$obj->uri (http://www.perl.com/SOAP);

Erhält oder einstellt das URI
, das als das namespace für die resultierende XML Körperschaft verwendet, wenn man gewünscht. Dieses einstellt nicht den Kennsatz für das namespace. Wenn man nicht mittels der Vorzeichenmethode zur Verfügung gestellt, festgelegt man automatisch egt, wenn es benötigt. Erlaubt auch die Einstellung des Nachrichtenwertes, wenn Sie als zweites Argument zur Methode passiert.

Vorzeichen (neues Vorzeichen, wahlweisewert)
$obj->prefix (Perl);

Zur Verfügung stellt das Vorzeichen oder Kennsatz, für Gebrauch, wenn, das Datenobjekt mit einem spezifischen namespace dazugehörend. Erlaubt auch die Einstellung des Nachrichtenwertes, wenn Sie als zweites Argument zur Methode passiert.

attr (Durcheinanderhinweis von Attributen, von wahlweisewert)
$obj->attr ({=> attr1 Wert});

Zuläßt die Einstellung der willkürlichen Attribute auf dem Datenobjekt. Im Verstand die Bedingung halten, dass irgendein nicht gediegen bekannt seife muß namespace-gekennzeichnet werden zuschreibt. Erlaubt auch die Einstellung des Nachrichtenwertes, wenn Sie als zweites Argument zur Methode passiert.

Wert (neuer Wert)
$obj->value (10);

Holt den aktuellen Wert, der durch die Nachricht eingekapselt oder einstellt ihn ausdrücklich hn.
Die letzten vier Methoden sind Hilfsabkürzungen für die Attribute, die Träger EINSEIFEN. Jedes ermöglicht auch Einbeziehung eines neuen Wertes, als wahlweise zweites Argument.

Schauspieler (neuer Schauspieler, wahlweisewert)
$obj->actor ($new_actor_name);

Erhalten oder einstellen den Wert des Schauspielerattributes; nützlich, nur wenn die Nachricht eine Körperschaft für den Nachrichtenvorsatz festlegt.

mustUnderstand (Boolesches, wahlweise Wert)
$obj->mustUnderstand (0);

Manipuliert das mustUnderstand Attribut, das dem SEIFEN-Prozessor mitteilt, ob es benötigt, die fragliche Körperschaft zu verstehen.

encodingStyle (neue kodierung URNE, wahlweisewert)
$obj->encodingStyle ($soap_11_encoding);

Diese Methode ist höchstwahrscheinlich, in den Plätzen außerhalb der Vorsatzkreation verwendet zu werden. Einstellt encodingStyle lt, das eine kodierung spezifiziert, die von der unterscheidet, der anders geführt sein zu.

Wert der Wurzel (Boolesches, wahlweise)
$obj->root (1);

Wenn die Anwendung ausdrücklich spezifizieren muß, welches Datenelement als das Wurzelelement um des Generierung des Nachrichtenbaumusters willen betrachtet werden soll, bietet diese Methode den Zugang zum Wurzelattribut.

Sternchen-Seife ist eine ausdehnbare seife (Web-Dienstleistungen) API mit dem Ziel, zum aller Sternchenkonfigurationsmerkmale zu erstellen und zu unterstützen.

Merkmal der Sternchen-Seifen-API hauptsächlich ist, einen Rahmen zwischen Sternchenkern API und Multiplattform frontends zur Verfügung zu stellen.

SEIFE:: XML:: Klient:: DotNet ist eine Perl-Baugruppe, zum mit .net webservices zu sprechen.

Dieses Paket hilft bei der Unterhaltung mit .net-Servers, benötigt es gerade ein Bit von XML geworfen an ihm und Sie erhalten irgendein XML rückseitig. Sein konzipiert, um WIRKLICH einfach zu sein zu verwenden.

Sie brauchen nicht, dieses, aber den Hauptunterschied zu kennen, um EINZUSEIFEN:: XML:: Klient:: Ist es eingibt wie generisch:

SOAPAction: „http://www.yourdomain.com/services/GetSellerActivity“

und setzt nicht in namesp< X >

SEIFE:: XML:: Klient:: Ist eine Perl-Baugruppe generisch, zum mit generischen webservices, z.B. nicht .net zu sprechen.

Dieses Paket hilft bei der Unterhaltung mit SEIFENweb server, benötigt es gerade ein Bit von XML geworfen an ihm und Sie erhalten irgendein XML rückseitig. Sein konzipiert, um WIRKLICH einfach zu sein zu verwenden, versucht es nicht, Spalter in jeder Hinsicht (Änderungen am Objektprogramm für cleaverness Willkommen) zu sein.

Der Hauptunterschied zur SEIFE:: XML:: Klient:: DotNet ist es eingibt wie:

SOAPAction: „http://www.yourdomain.com/services#GetSellerActivity“

und namesp< X > addiert dem XML, das eingegeben und einschließt für die xmlns.

seife Schnittstelle Java-GForge (oder JaGoSI kurz) ist ein Anflug, zum auf der GForge Zusammenarbeitsplattform über Java zurückzugreifen. Dieses kann verwendet werden, um andere Anwendungen oben auf JaGoSI zu setzen. Es kann mit anderen Anwendungen wie dem ehemaligen Plastik-Projekt integriert werden.

Was in diesem Auslösen neu ist:

· Eine komplette Arbeitsdateiverteilung ist für die GForge Plattform über eine Ameisenaufgabe erhältlich.
· Viele Marken waren örtlich festgelegt.
· Der Kennerbau war örtlich festgelegt, also arbeitet das Kompilieren mit Vorteilen.
· Die Projektzelle geändert.
· JUnit geändert zu Version 4.

ASNMTAP:: Asnmtap:: Steckverbindungen:: seife ist eine Perl-Baugruppe, die die SEIFEN-Funktionen liefert, die durch ASNMTAP-gegründete Steckverbindungen verwendet.

SYNOPSE

Gebrauch ASNMTAP:: Asnmtap:: Steckverbindungen v3.000.010;
Gebrauch ASNMTAP:: Asnmtap:: Steckverbindungen qw (: STECKVERBINDUNGEN);

mein $objectPlugins = ASNMTAP:: Asnmtap:: Plugins->new (
_programName => check_template-SOAP.pl,
_programDescription => „SEIFE:: LITE-steckbare Schablone für die Prüfung des $APPLICATION mit Leistungs-Daten“,
_programVersion => 3.000.010,
_programGetOptions => [Vollmacht: s, trendline|T: I],
_timeout => 30,
_debug => 0);

Gebrauch ASNMTAP:: Asnmtap:: Steckverbindungen:: seife qw (≥t_soap_request);

Gebrauch SEIFE:: Lite;
mein $proxy = http://services.soaplite.com/hibye.cgi;
mein $namespace = http://www.soaplite.com/Demo;
mein $methodName = hallo;
mein $method = SEIFE:: Data->name ($methodName) - >attr ({xmlns => $namespace});

mein %soapService_Register_NS = (
http://schemas.xmlsoap.org/wsdl/mime/ => Pantomime,
http://www.w3.org/2001/XMLSchema => s
);

mein $xmlContent;
mein $params;

mein ($returnCode, $xml) = get_soap_request (
asnmtapInherited => $objectPlugins,
Vollmacht => $proxy,
namespace => $namespace,
Methode => $method,
registerNamespace => %soapService_Register_NS,
xmlContent => $xmlContent,
Params => $params,
Plätzchen => 1,
perfdataLabel => seife
);

es sei denn ($returnCode) {
wenn (definiertes $xml) {
…
} sonst {
…
}
}

$objectPlugins->exit (7);

SEIFE:: Lite für Perl ist eine Ansammlung Perl-Baugruppee, die eine einfache und leichte Schnittstelle zum einfachen Nachrichten-Zugriffs-Protokoll (SEIFE, alias dienstleistungsorientiertes Zugriffs-Protokoll) beide auf Klienten- und Serverseite zur Verfügung stellt.

get_soap_request ()

seife ist ein einfaches XML-gegründetes Protokoll, zum von Anwendungsaustauschinformationen über HTTP zu lassen.
Mehr Informationen betreffend seife können Entdeckung an URI sein: http://www.w3schools.com/soap/
Zurückbringt einen Status für $returnCode Status (OKAY. .UNKNOWN) und wenn der Status für $xml das extrahierte XML OKAY ist, wenn existiert, andernfalls undef.

asnmtapInherited

Ein erforderlicher Hinweis auf einem ASNMTAP:: Asnmtap:: Steckverbindungen oder ASNMTAP:: Asnmtap:: Steckverbindungen:: Nagios Unterklasse

Durch diese arbeitende Methode von übernahmen uns die Befehlszeile Option --ausprüfen.

Zoll

, ist ein Hinweis auf Ihrer eigenen kundenspezifischen definierten Funktion wahlweise
$som: die SOM-Nachricht zur Verfügung stellt eine einfache API für den Zugriff jedes möglichen Aspekts des Warte-SEIFEN-Umschlags, eine Resultatsnachricht von der SEIFE:: Lite.
VoractionOnSoapResponse {
mein ($asnmtapInherited, $som) = @_;
Umsatz ($returnCode);
}
und jetzt mit customArguments:
VoractionOnSoapResponse {
mein ($asnmtapInherited, $som, $arguments) = @_;
Umsatz ($returnCode);
}
customArguments
wahlweise, wenn Sie Parameter zu Ihrer eigenen kundenspezifischen definierten Funktion führen müssen, kann dieses mit customArguments getan werden.
customArguments: SCALAR, REIHE, DURCHEINANDER,
HINWEISSCALAR, HINWEIS-REIHE, HINWEIS-DURCHEINANDER
Vollmacht
Dieses läßt Sie einen Endpunkt (Service-Adresse) spezifizieren und lädt auch die erforderliche Baugruppe gleichzeitig.
Vollmacht: http://services.soaplite.com/hibye.cgi
ein erforderlicher Scalar.
namespace
Einstellt das URI
, das als das namespace für die resultierende XML Körperschaft verwendet.
namespace: http://www.soaplite.com/Demo
ein erforderlicher Scalar.
registerNamespace
Die register_ns Subroutine erlaubt Benutzern, ein globales namespace mit dem seife Umschlag zu registrieren.
registerNamespace:

%soapService_Register_NS = (
http://schemas.xmlsoap.org/wsdl/mime/ => Pantomime,
http://www.w3.org/2001/XMLSchema => s
);
ein erforderliches Durcheinander.
Methode

Der Name ist, was der Serializer für die Marke verwendet, wenn es das XML für diese Nachricht festlegt.

Methode: SEIFE:: Data->name (hallo) - >attr ({xmlns => http://www.soaplite.com/Demo});
eine erforderliche SEIFE:: Data->name Definition

AlchemySOAP ist eine Gabel der Bibliothek der EasySoap++ seife 1.1. Hinzufügen des erhöhten Protokollträgers (SEIFE 1.2), vieler automatisierten Gerätenprüfungen und der Interoperabilitätsprüfungen und einiger anderer bemerkenswerter Merkmale (mehrfädige SEIFEN-Anforderungsbearbeitung, wahlweiseSSL/DOM, Veröffentlichungverbesserungen, zum mit WS-* Protokollen zu arbeiten, usw.). Diese Bibliothek ist die offene Quelle, genehmigt unter dem LGPL.

AlchemySOAP kann mit vielen 3. Party SEIFEN-Stapeln interagieren und einschließen: Apache, Mitgliedstaat-SEIFE Toolkit, gSoap, SEIFE:: Lite, SQL-Daten und weißes MESA.

Was in diesem Auslösen neu ist:

· Für seife 1.2 unterstützen addiert.
· Die SOAPServer und SOAPServerDispatch Kategorien refactored, um das mehrfädige Handhaben von Anträgen zu erlauben.
· Periodische Veröffentlichung und deserialization der Xerces-C Elemente unterstützt.
· Einsparung whitespace zwischen SEIFEN-Elementen während des deserialization und dem Enthalten es während der periodischen Veröffentlichung unterstützt.
· Dieses läßt eine SEIFEN-Meldung das selbe nach der deserialization oder Veröffentlichungschleife (die bleiben für WS-Sicherheit erforderlich ist).

ebXML:: Meldung ist eine Perl-Baugruppe, zum einer ebMS Meldung einzukapseln.

SYNOPSE

Gebrauch ebXML:: Meldung;

# neue Meldung erstellen

mein $message = ebXML:: Message->new
(
CPAId => http://www.you.org/cpa/123456,
Maßnahmen => NewPurchaseOrder,
MessageId => 12,
RefMessageToId => 11,
=> ebXML instandhalten:: Meldung:: Service->new
(
WERT => QuoteToCollect,
=> myservicetypes schreiben,
),
);

# seife XML using DOM schreiben

Gebrauch XML:: Xerses;

# DOM-Dokument
mein $target = XML:: Xerces:: StdOutFormatTarget->new ();
$writer->writeNode ($target, $message->getOutput (DOM-Doc.);

# festlegten DOM xml,/munged XML
ausdrucken $message->getOutput (DOM-XML);


# Gebrauchmeldung mit SEIFE:: Lite zum Rufen webservice

Gebrauch SEIFE:: Lite;

# SEIFE:: Daten:: Erbauernachricht
mein $result = SEIFE:: Lite->uri (http://uri.to/WebService)
- >proxy (http://uri.to/soap.cgi)
- >parts ($message->getMIMEParts)
- >call ($message->getOutput (Seife-Daten))
- >result;

# SEIFE:: Daten:: Erbauer festlegte xml,/munged XML
ausdrucken $message->getOutput (SOAP-XML);

Eine ebXML Meldung einkapselt alle Details einer ebMS Meldung.
ebXML ist eine Vorrichtung für das Sicherstellen der zuverlässigen Anlieferung der XML-gegründeten Meldungen über eine Transportvorrichtung wie SEIFE. Für weitere Einzelheiten über ebXML, http://www.ebxml.org/ sehen
Große Teile dieser manuellen Seite kopiert direkt von der ebMS 2.0 Bedingung.

Geschäftsorientiert Rahmen (BOF) ist ein Perl-Applikationsserver. Er verwendet die SEIFE, wahlweise gesichert mit SSL, um mit dem Klienten zu verständigen.

Der Klient kann seife verwenden:: Lite oder die Klientenbaugruppe eingeschlossen in BOF, sie einfach bildend, an den Server anzuschließen. Benutzer, grou

Was in diesem Auslösen neu ist:

· Addierter Träger für Programme und Aufgaben

Yahoo:: Vermarkten:: AdService ist eine Nachricht, die Zugang zum Yahoo-Marketing-Anzeige seife Service bietet.

SYNOPSE

EWS Unterlagen für erhältliche SEIFEN-Methoden online sehen:
http://ysm.techportal.searchmarketing.yahoo.com/docs/reference/services/AdService.asp

Perldoc Yahoo auch sehen:: Vermarkten:: Service für die Funktionalität geläufig für alle Testmoduln.

neu

Erstellt einen neuen Fall

Netz:: Google:: Rechtschreibung ist eine einfache OOP-ish Schnittstelle zur Google seife API für Rechtschreibungvorschläge.

SYNOPSE

Gebrauch Netz:: Google:: Rechtschreibung;
mein $spelling = Netz:: Google:: Rechtschreibung (%args);

$spelling->phrase („muntreal qweebec“);
Druck $spelling->suggest (). „N“;

Zur Verfügung stellt eine einfache OOP-ish Schnittstelle zur Google seife API für Rechtschreibungvorschläge.

Dieses Paket verwendet von Net:: Google.

Netz:: Google:: Cache ist eine einfache OOP-ish Schnittstelle zur Google seife API für cachierte Dokumente.

SYNOPSE

Gebrauch Netz:: Google:: Cache;
mein $cache = Netz:: Google:: Cache (%args);

$cache->url („http://aaronland.net);
Druck $cache->get ();

Zur Verfügung stellt eine einfache OOP-ish Schnittstelle zur Google seife API für cachierte Dokumente.
Dieses Paket verwendet von Net:: Google.

Apache:: No404Proxy:: Google ist eine Umsetzung von Apache:: No404Proxy.

SYNOPSE

# in httpd.conf
PerlTransHandler Apache:: No404Proxy:: Google
PerlSetVar GoogleLicenseKey **************

Apache:: No404Proxy:: Google ist eine der Umsetzungen von Apache:: No404Proxy. Diese Baugruppe verwendet SEIFE:: Lite, zum des Google Caches zu holen.

csoap ist eine SEIFENanwenderbibliothek in reinem C.

csoap ist ein schnelles und eine leichte Art, einen SEIFEN-Klienten oder einen SEIFEN-Server in eine Anwendung einzubetten, die in C. geschrieben. Es aufgebaut oben auf libxml2 ut und unterstützt SSL-und HTTP-grundlegende Authentisierung.

Aclocal/Automobil Howto Gebrauch (conf, bilden), der in Ihrem libsoap vorsteht ht

1. Die Datei libcsoap.m4 zum aclocal `kopieren --DruckenwS-dir `
2. Die folgenden Leitungen Ihrem configure.in (oder configure.ac) addieren:
dnl AM_PATH_CSOAP ([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
AM_PATH_CSOAP (1.0.4)
CFLAGS= " CFLAGS CSOAP_CFLAGS "
LDFLAGS= " $LDFLAGS CSOAP_LIBS "

Dank Heiko Ronsdorf