Attributes  edit

current version

1.6.7

Download  edit

   http://sourceforge.net/projects/tclsoap/files/

dom patch

DcK 2013-01-05: patch for compatibility with with recent dom packages.

ActiveTcl

includes TclSOAP

Dependencies  edit

http

TclDOM

tcllib

Documentation  edit

   http://tclsoap.sourceforge.net/

Development  edit

http://sourceforge.net/projects/tclsoap

Description  edit

See Also  edit

Googling with SOAP

a simple accessor for the Google API using TclSOAP

Change Log  edit

1.6.6

   [REpresentational State Transfer, REST]:

SSL  edit

TclSOAP and SSL (Secure Sockets Layer) ,David Bleicher ,2002

package require SOAP::https

WSDL  edit

SOAP::service http://tclsoap.sf.net/WSDL/silab.wsdl
SOAP::service file:///usr/local/etc/WSDL/interop.wsdl

WS-Security  edit

tsoap  edit

cvs.openacs.org

WSDL Generator  edit

WSDL generator

Lost  edit

http://gondolin.hist.liv.ac.uk/~cheshire/tclgoogle.html

Examples  edit

http://tclsoap.sf.net/

• A simple SOAP call to a Perl implemented service using http.

% package require SOAP
1.6
% SOAP::create c2f -uri http://www.soaplite.com/Temperatures \
     -proxy http://services.soaplite.com/temper.cgi \
     -params { "temp" "float" }
::c2f
% c2f -40.0
24.8

• SOAP over SMTP (sends the request to the proxy url).

% package require SOAP::smtp
1.0
% SOAP::configure -transport mailto -servers smtp.localdomain.org
% SOAP::create POSSale -uri urn:tclsoap::POS \
    -proxy mailto:[email protected] \
    -params { productid string amount float operator string }
::POSSale
% POSSale "0123232-0912" 10.00 "Sally"
%

• SOAP over FTP

% package require SOAP::ftp
1.0
% SOAP::create POSSale -uri urn:tclsoap:POS \
    -proxy ftp://anonymous:[email protected]/soap/POS \
    -params { productid string amount float operator string }
::POSSale
% POSSale "0123232-0912" 10.00 "Sally"

# Declare required libraries.
package require SOAP
package require Tk

# Create a simple GUI display.  Bind the entry display
#     to "zipcode".
entry .my_entry -textvariable zipcode
label .my_label
pack .my_entry .my_label

# describes this service.
set URI urn:xmethods-Temperature
set URL http://services.xmethods.net/soap/servlet/rpcrouter

# Bind a local command to the remote service.
SOAP::create getTemp -uri $URI -proxy $URL -params {zipcode string}

# Invoke the SOAP-mediated local command when the user
#    pushes the "Return" key.  Display the return value.
bind <Return> .my_entry  {
    .my_label configure -text \
        "The temperature at $zipcode is [getTemp $zipcode]."
}     

http://www.danmarinescu.com/webservices.htm

• Position: char[64], starting from upper left, ending to upper right, empty squares are spaces, universal chess notation (whites are capitals), whites are always down. You will have to send the position every single time you access the interface. For example, the initial position will be: "rnbqkbnrpppppppp {insert 4*8=32 spaces in here!} PPPPPPPPRNBQKBNR" (the spaces for empty squares are mandatory).
• WhiteMovesNext: bool, defaulted to true.
• SearchDepth: int, defaulted to 3, this would be the search depth of the Chess algorithm (please do not abuse the server, do not send values bigger than 5). The default value (3) stands for about 2100 elo... The thinking time growth is an exponential of the search depth

package require SOAP
set uri "urn:BorlandChess-IBorlandChess#XML_GetNextMove"
set proxy "http://www.danmarinescu.com/WebServices/ChessCGIServer.exe/soap/IBorlandChess"
SOAP::create XML_GetNextMove \
     -uri $uri -proxy $proxy \
     -params {"Position" "string" "WhiteMovesNext" "boolean" "SearchDepth" "integer"}
XML_GetNextMove "rnbqkbnrpppppppp[string repeat { } 32]PPPPPPPPRNBQKBNR" true 3  
# returns "e2e4 OK"

package require SOAP
set uri "urn:xmethods-EbayWatcher"
set proxy "http://services.xmethods.net:80/soap/servlet/rpcrouter"
SOAP::create getCurrentPrice -uri $uri -proxy $proxy \
 -params {"auction_id" "string"}
#getCurrentPrice 3218123285  ;# use a valid auction item number from ebay

Discussion  edit

http://tclsoap.sourceforge.net/dom-packages.html

http://sourceforge.net/projects/tclxml

# override the SOAP::insert_value command:
proc ::SOAP::insert_value {node value} {

    set type     [rpctype $value]
    set subtype  [rpcsubtype $value]
    set attrs    [rpcattributes $value]
    set headers  [rpcheaders $value]
    set value    [rpcvalue $value]
    set typeinfo [typedef -info $type]
    set typexmlns [typedef -namespace $type]

    # Handle any header elements
    if {$headers != {}} {
        insert_headers $node $headers
    }
    
    # If the rpcvar namespace is a URI then assign it a tag and ensure we
    # have our colon only when required.
    if {$typexmlns != {} && [regexp : $typexmlns]} {
        dom::element setAttribute $node "xmlns:t" $typexmlns
        set typexmlns t
    }
    if {$typexmlns != {}} { append typexmlns : }

    # If there are any attributes assigned, apply them.
    if {$attrs != {}} {
        foreach {aname avalue} $attrs {
            dom::element setAttribute $node $aname $avalue
        }
    }

    if {[string match {*()} $typeinfo] || [string match {*()} $type] 
        || [string match array $type]} {
        # array type: arrays are indicated by one or more () suffixes or
        # the word 'array' (depreciated)

        if {[string length $typeinfo] == 0} {
            set dimensions [regexp -all -- {\(\)} $type]
            set itemtype [string trimright $type ()]
            if {$itemtype == "array"} {
                set itemtype ur-type
                set dimensions 1
            }
        } else {
            set dimensions [regexp -all -- {\(\)} $typeinfo]
            set itemtype [string trimright $typeinfo ()]
        }
        
        # Look up the typedef info of the item type
        set itemxmlns [typedef -namespace $itemtype]
        if {$itemxmlns != {} && [regexp : $itemxmlns]} {
            dom::element setAttribute $node "xmlns:i" $itemxmlns
            set itemxmlns i
        }
        
        # Currently we do not support non-0 offsets into the array.
        # This is because I don;t know how I should present this to the
        # user. It's got to be a dynamic attribute on the value.
        dom::element setAttribute $node \
                "xmlns:SOAP-ENC" "http://schemas.xmlsoap.org/soap/encoding/"
        dom::element setAttribute $node "xsi:type" "SOAP-ENC:Array"
        dom::element setAttribute $node "SOAP-ENC:offset" "\[0\]"

        # we need to break a multi-dim array into r0c0,r0c1,r1c0,r1c1
        # so list0 followed by list1 etc.
        # FIX ME
        set arrayType "$itemxmlns:$itemtype"
        #for {set cn 0} {$cn < $dimensions} {incr cn}
        append arrayType "\[[llength $value]\]"
        dom::element setAttribute $node "SOAP-ENC:arrayType" $arrayType

        foreach elt $value {
            set d_elt [dom::document createElement $node "item"]
            if {[string match "ur-type" $itemtype]} {
                insert_value $d_elt $elt
            } else {
                insert_value $d_elt [rpcvar $itemtype $elt]
            }
        }
    } elseif {[llength $typeinfo] > 1} {
        # a typedef'd struct.
        if {$typexmlns != {}} {
            dom::element setAttribute $node "xsi:type" "${typexmlns}${type}"
        }
        array set ti $typeinfo
        # Bounds checking - <[email protected]>
        if {[llength $typeinfo] != [llength $value]} {
            return -code error "wrong # args:\
                type $type contains \"$typeinfo\""
        }
        foreach {eltname eltvalue} $value {
            set d_elt [dom::document createElement $node $eltname]
            if {![info exists ti($eltname)]} {
                return -code error "invalid member name:\
                    \"$eltname\" is not a member of the $type type."
            }
            insert_value $d_elt [rpcvar $ti($eltname) $eltvalue]
        }
    } elseif {$type == "struct"} {
        # an unspecified struct
        foreach {eltname eltvalue} $value {
            set d_elt [dom::document createElement $node $eltname]
            insert_value $d_elt $eltvalue
        }
    } elseif {$type == "xml"} {
        # straight xml that needs to be inline'd
        set subdoc [dom::parse $value]
        set newnode [dom::node appendChild $node\
                [dom::document cget $subdoc -documentElement]]
        dom::element setAttribute $node "xsi:type" "xsd:string"
    } else {
        # simple type or typedef'd enumeration
        if {$typexmlns != {}} {
            dom::element setAttribute $node "xsi:type" "${typexmlns}${type}"
        }
        dom::document createTextNode $node $value
    }
}

# create your SOAP command:
SOAP::create foo -proxy http://myfoo.bar.com -uri "urn:foo.bar" -action "urn:foo.bar" -params {name string zipcode integer userdetails xml}
# run that command:
foo "Mr Foo" "4001" "<userdetails><favourites color=\"blue\" food=\"chocolate\"/><profession>1337 h4x0r</profession></userdetails>"

source tclhttpd3.3/bin/httpd.tcl ;# start the web server
package require SOAP
package require SOAP::Domain
SOAP::Domain::register -prefix /soap -namespace zsplat::Test

# Define a server procedure to return some XML
proc xml {} {
    return {<?xml version="1.0" ?><Memo/>}
}

SOAP::create zxml -proxy http://localhost:8015/soap/xml -uri zsplat-Test
zxml

<?xml version='1.0'?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/1999/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/1999/XMLSchema"><SOAP-ENV:Body><ns:return xmlns:ns="zsplat-Test" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><return xsi:type="xsd:string">&lt;?xml version=&quot;1.0&quot;?&gt;&lt;Memo/&gt;</return></ns:return></SOAP-ENV:Body></SOAP-ENV:Envelope>

• The above code will only work for versions prior to 1.6. For newer versions you would create a tcl script file with the method implementation and place it into a directory. Then start tclhttpd, source tclserver.tcl, set the SOAP::CGI::soapdir variable and let rip. Also, newer code needs to be 'exported'. This is so that callers cannot execute arbitrary tcl commands like exec. PT

package require rpcvar
namespace import rpcvar::typedef

typedef {
   intValue    int
   floatValue  float
   stringValue string
} SoapStruct

SOAP::create someMethod -params {aStruct SoapStruct}
someMethod {intValue 2 floatValue 3.5 stringValue "Hello World"}

http://tclsoap.sourceforge.net/

source tclhttpd/bin/httpd.tcl
source tclsoap/samples/tclserver.tcl

http://tclsoap.sf.net/SOAP-CGI.html

% package require SOAP
can't find package uri
% package require uri
can't find package uri

% package require logger 0.3
0.9

teacup install package-name

teacup update

• Home
• Recent changes
• Help
• WhoAmI/Logout
• Create new page
• Random page
• Previous page
• Next page
• 
  
• Add comments
• Edit
• History
• Edit summary
• References