spoe

README

SPOE in Go

An implementation of the SPOP protocol in Go. (https://www.haproxy.org/download/1.9/doc/SPOE.txt)

SPOE

From Haproxy's documentation :

SPOE is a feature introduced in HAProxy 1.7. It makes possible the communication with external components to retrieve some info. The idea started with the problems caused by most ldap libs not working fine in event-driven systems (often at least the connect() is blocking). So, it is hard to properly implement Single Sign On solution (SSO) in HAProxy. The SPOE will ease this kind of processing, or we hope so.

Now, the aim of SPOE is to allow any kind of offloading on the streams. First releases, besides being experimental, won't do lot of things. As we will see, there are few handled events and even less actions supported. Actually, for now, the SPOE can offload the processing before "tcp-request content", "tcp-response content", "http-request" and "http-response" rules. And it only supports variables definition. But, in spite of these limited features, we can easily imagine to implement SSO solution, ip reputation or ip geolocation services.

How to use

package main

import (
        "fmt"
        "net"

        log "github.com/sirupsen/logrus"
        "github.com/aestek/haproxy-connect/spoe"
)

func getReputation(ip net.IP) (float64, error) {
	// implement IP reputation code here
        return 1.0, nil
}

func main() {
	agent := spoe.New(func(messages []spoe.Message) ([]spoe.Action, error) {
		reputation := 0.0

		for _, msg := range messages {
			if msg.Name != "ip-rep" {
				continue
			}

			ip, ok := msg.Args["ip"].(net.IP)
			if !ok {
				return nil, fmt.Errorf("spoe handler: expected ip in message")
			}

			reputation, err = getReputation(ip)
			if err != nil {
				return nil, fmt.Errorf("spoe handler: error processing request: %s", err)
			}
		}

		return []spoe.Action{
			spoe.ActionSetVar{
				Name:  "reputation",
				Scope: spoe.VarScopeSession,
				Value: reputation,
			},
		}, nil
	})

	if err := agent.ListenAndServe(":9000"); err != nil {
		log.Fatal(err)
	}
}

Documentation

Index

• Constants
• type Action
• type ActionSetVar
• type ActionUnsetVar
• type Agent
  • func New(h Handler) *Agent
  • func (a *Agent) ListenAndServe(addr string) error
  • func (a *Agent) Serve(lis net.Listener) error
• type Handler
• type Message

Constants

const (
	VarScopeProcess     varScope = 0
	VarScopeSession     varScope = 1
	VarScopeTransaction varScope = 2
	VarScopeRequest     varScope = 3
	VarScopeResponse    varScope = 4
)

Types

type Action

type Action interface {
	// contains filtered or unexported methods
}

type ActionSetVar

type ActionSetVar struct {
	Name  string
	Scope varScope
	Value interface{}
}

type ActionUnsetVar

type ActionUnsetVar struct {
	Name  string
	Scope varScope
}

type Agent

type Agent struct {
	Handler Handler
	// contains filtered or unexported fields
}

func New

func New(h Handler) *Agent

func (*Agent) ListenAndServe

func (a *Agent) ListenAndServe(addr string) error

func (*Agent) Serve

func (a *Agent) Serve(lis net.Listener) error

type Handler

type Handler func(args []Message) ([]Action, error)

type Message

type Message struct {
	Name string
	Args map[string]interface{}
}