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"
 "log"
 "net/http"

 "github.com/3ideas/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.Log = func(msg string, keyString_ValueInterface ...interface{}) {
  keyString_ValueInterface = append(keyString_ValueInterface, msg)
  var values []interface{}
  values = append(values, "SOAP Server: ")
  values = append(values, keyString_ValueInterface...)
  log.Println(values...)
 }

 soapServer.RegisterHandler(
  "/",            // Path
  "operationFoo", // SOAPAction
  "fooRequest",   // tagname of soap body content
  func() interface{} { // RequestFactoryFunc - returns struct to unmarshal the request into
   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 := http.ListenAndServe(":8089", soapServer)
 fmt.Println("exiting with error", err)
}

func main() {
 RunServer()
}

Client

package main

import (
 "context"
 "encoding/xml"
 "log"

 "github.com/3ideas/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)
 client.Log = func(msg string, keyString_ValueInterface ...interface{}) {
  keyString_ValueInterface = append(keyString_ValueInterface, msg)
  log.Println(keyString_ValueInterface...)
 } // verbose
 response := &FooResponse{}
 httpResponse, err := client.Call(context.Background(), "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 OperationHandlerFuncWithInfo
• type RequestFactoryFunc
• type Server
  • func NewServer() *Server
  • func (s *Server) RegisterHandler(path string, action string, messageType string, ...)
  • func (s *Server) RegisterHandlerWithInfo(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 (
	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
	LogLevel int                                                       // 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 OperationHandlerFuncWithInfo

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

OperationHandlerFuncWithInfo A modified operational handler function that also passes in an optional information field that can be used to pass in extra information about the request. Its type is upto the handler to define.

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.*
	Log func(msg string, keyString_ValueInterface ...interface{})

	Marshaller  XMLMarshaller
	ContentType string
	SoapVersion string
	LogLevel    int
	// 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) RegisterHandlerWithInfo

func (s *Server) RegisterHandlerWithInfo(path string, action string, messageType string, requestFactory RequestFactoryFunc, operationHandlerFunc OperationHandlerFuncWithInfo, reqStruct interface{}, handlerInfo interface{})

RegisterHandlerWithInfo Register a slightly differenct handler function, to enable auto generation of the Reqest struct from the type. also the modiled 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