soap

README

SOAP is dead - long live SOAP

First of all do not write SOAP services if you can avoid it! It is over.

If you can not avoid it this package might help.

Service

package main

import (
	"encoding/xml"
	"fmt"
	"net/http"

	"github.com/globusdigital/soap"
)

// FooRequest a simple request
type FooRequest struct {
	XMLName xml.Name `xml:"fooRequest"`
	Foo     string
}

// FooResponse a simple response
type FooResponse struct {
	Bar string
}

// RunServer run a little demo server
func RunServer() {
	soapServer := soap.NewServer()
	soapServer.HandleOperation(
		// SOAPAction
		"operationFoo",
		// tagname of soap body content
		"fooRequest",
		// RequestFactoryFunc - give the server sth. to unmarshal the request into
		func() interface{} {
			return &FooRequest{}
		},
		// OperationHandlerFunc - do something
		func(request interface{}, w http.ResponseWriter, httpRequest *http.Request) (response interface{}, err error) {
			fooRequest := request.(*FooRequest)
			fooResponse := &FooResponse{
				Bar: "Hello " + fooRequest.Foo,
			}
			response = fooResponse
			return
		},
	)
	err := soapServer.ListenAndServe(":8080")
	fmt.Println("exiting with error", err)
}

func main() {
	RunServer()
}

Client

package main

import (
	"encoding/xml"
	"log"

	"github.com/globusdigital/soap"
)

// FooRequest a simple request
type FooRequest struct {
	XMLName xml.Name `xml:"fooRequest"`
	Foo     string
}

// FooResponse a simple response
type FooResponse struct {
	Bar string
}

func main() {
	client := soap.NewClient("http://127.0.0.1:8080/", nil)
	response := &FooResponse{}
	httpResponse, err := client.Call("operationFoo", &FooRequest{Foo: "hello i am foo"}, response)
	if err != nil {
		panic(err)
	}
	log.Println(response.Bar, httpResponse.Status)
}

Apache License Version 2.0

Documentation

Index

• Constants
• type BasicAuth
• type Body
  • func (b *Body) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
• type Client
  • func NewClient(postToURL string, auth *BasicAuth) *Client
  • func (c *Client) Call(ctx context.Context, soapAction string, request, response interface{}) (*http.Response, error)
  • func (c *Client) UseSoap11()
  • func (c *Client) UseSoap12()
• type Envelope
• type Fault
  • func (f *Fault) Error() string
• type Header
• type OperationHandlerFunc
• type RequestFactoryFunc
• type Server
  • func NewServer() *Server
  • func (s *Server) RegisterHandler(path string, action string, messageType string, ...)
  • func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request)
  • func (s *Server) UseSoap11()
  • func (s *Server) UseSoap12()
  • func (s *Server) WriteHeader(w http.ResponseWriter, code int)
• type XMLMarshaller

Constants

const (
	AppVersion    = "v1.3.3"
	SoapVersion11 = "1.1"
	SoapVersion12 = "1.2"

	SoapContentType11 = "text/xml; charset=\"utf-8\""
	SoapContentType12 = "application/soap+xml; charset=\"utf-8\""

	NamespaceSoap11 = "http://schemas.xmlsoap.org/soap/envelope/"
	NamespaceSoap12 = "http://www.w3.org/2003/05/soap-envelope"
)

Types

type BasicAuth

type BasicAuth struct {
	Login    string
	Password string
}

BasicAuth credentials for the client

type Body

type Body struct {
	XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Body"`

	Fault               *Fault      `xml:",omitempty"`
	Content             interface{} `xml:",omitempty"`
	SOAPBodyContentType string      `xml:"-"`
}

Body type

func (*Body) UnmarshalXML

func (b *Body) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

UnmarshalXML implement xml.Unmarshaler

type Client

type Client struct {
	Log func(msg string, keyString_ValueInterface ...interface{}) // optional

	Marshaller      XMLMarshaller
	UserAgent       string            // optional, falls back to "go-soap-0.1"
	ContentType     string            // optional, falls back to SOAP 1.1
	RequestHeaderFn func(http.Header) // optional, allows to modify the request header before it gets submitted.
	SoapVersion     string
	HTTPClientDoFn  func(req *http.Request) (*http.Response, error)
	// contains filtered or unexported fields
}

Client generic SOAP client

func NewClient

func NewClient(postToURL string, auth *BasicAuth) *Client

NewClient constructor. SOAP 1.1 is used by default. Switch to SOAP 1.2 with UseSoap12(). Argument rt can be nil and it will fall back to the default http.Transport.

func (*Client) Call

func (c *Client) Call(ctx context.Context, soapAction string, request, response interface{}) (*http.Response, error)

Call makes a SOAP call

func (*Client) UseSoap11

func (c *Client) UseSoap11()

func (*Client) UseSoap12

func (c *Client) UseSoap12()

type Envelope

type Envelope struct {
	XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Envelope"`
	Header  Header
	Body    Body
}

Envelope type `xml:"http://schemas.xmlsoap.org/soap/envelope/ Envelope"`

type Fault

type Fault struct {
	XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault"`

	Code   string `xml:"faultcode,omitempty"`
	String string `xml:"faultstring,omitempty"`
	Actor  string `xml:"faultactor,omitempty"`
	Detail string `xml:"detail,omitempty"`
}

Fault type

func (*Fault) Error

func (f *Fault) Error() string

type Header

type Header struct {
	XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Header"`

	Header interface{}
}

Header type

type OperationHandlerFunc

type OperationHandlerFunc func(request interface{}, w http.ResponseWriter, httpRequest *http.Request) (response interface{}, err error)

OperationHandlerFunc runs the actual business logic - request is whatever you constructed in RequestFactoryFunc

type RequestFactoryFunc

type RequestFactoryFunc func() interface{}

RequestFactoryFunc constructs a request object for OperationHandlerFunc

type Server

type Server struct {
	Log func(...interface{}) // do nothing on nil or add your fmt.Print* or log.*

	Marshaller  XMLMarshaller
	ContentType string
	SoapVersion string
	// contains filtered or unexported fields
}

Server a SOAP server, which can be run standalone or used as a http.HandlerFunc

func NewServer

func NewServer() *Server

NewServer construct a new SOAP server

func (*Server) RegisterHandler

func (s *Server) RegisterHandler(path string, action string, messageType string, requestFactory RequestFactoryFunc, operationHandlerFunc OperationHandlerFunc)

RegisterHandler register to handle an operation. This function must not be called after the server has been started.

func (*Server) ServeHTTP

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*Server) UseSoap11

func (s *Server) UseSoap11()

func (*Server) UseSoap12

func (s *Server) UseSoap12()

func (*Server) WriteHeader

func (s *Server) WriteHeader(w http.ResponseWriter, code int)

WriteHeader first set the content-type header and then writes the header code.

type XMLMarshaller

type XMLMarshaller interface {
	Marshal(v interface{}) ([]byte, error)
	Unmarshal(xml []byte, v interface{}) error
}

XMLMarshaller lets you inject your favourite custom xml implementation