presence

Documentation

Index

• func NewDb() *db
• func NewService(db IDb) *service
• type CocoHostSanitizer
• type CoconodeSanitizer
  • func NewCoconodeSanitizer(p *bluemonday.Policy) CoconodeSanitizer
  • func (s *CoconodeSanitizer) Sanitize(input models.CocoHostInfo) models.CocoHostInfo
• type Config
• type Controller
  • func New(cfg Config) Controller
• type GatewayHostSanitizer
• type GatewaySanitizer
  • func NewGatewaySanitizer(p *bluemonday.Policy) GatewaySanitizer
  • func (s *GatewaySanitizer) Sanitize(input models.GatewayHostInfo) models.GatewayHostInfo
• type IDb
• type IMixNodeIDSanitizer
• type IPAssigner
• type IService
• type MixHostSanitizer
• type MixNodeIDSanitizer
  • func NewMixnodeIDSanitizer(p *bluemonday.Policy) MixNodeIDSanitizer
  • func (s *MixNodeIDSanitizer) Sanitize(input models.MixNodeID) models.MixNodeID
• type MixProviderHostSanitizer
• type MixnodeSanitizer
  • func NewMixnodeSanitizer(p *bluemonday.Policy) MixnodeSanitizer
  • func (s *MixnodeSanitizer) Sanitize(input models.MixHostInfo) models.MixHostInfo
• type MixproviderSanitizer
  • func NewMixproviderSanitizer(p *bluemonday.Policy) MixproviderSanitizer
  • func (s *MixproviderSanitizer) Sanitize(input models.MixProviderHostInfo) models.MixProviderHostInfo

Functions

func NewDb

func NewDb() *db

NewDb constructor...

func NewService

func NewService(db IDb) *service

NewService constructor

Types

type CocoHostSanitizer

type CocoHostSanitizer interface {
	Sanitize(models.CocoHostInfo) models.CocoHostInfo
}

CocoHostSanitizer cleans untrusted input fields

type CoconodeSanitizer

type CoconodeSanitizer struct {
	// contains filtered or unexported fields
}

CoconodeSanitizer kills untrusted input in CocoHostInfo structs

func NewCoconodeSanitizer

func NewCoconodeSanitizer(p *bluemonday.Policy) CoconodeSanitizer

NewCoconodeSanitizer constructor...

func (*CoconodeSanitizer) Sanitize

func (s *CoconodeSanitizer) Sanitize(input models.CocoHostInfo) models.CocoHostInfo

Sanitize CocoHostInfo input

type Config

type Config struct {
	CocoHostSanitizer        CocoHostSanitizer
	MixHostSanitizer         MixHostSanitizer
	MixNodeIDSanitizer       IMixNodeIDSanitizer
	MixProviderHostSanitizer MixProviderHostSanitizer
	GatewayHostSanitizer     GatewayHostSanitizer
	Service                  IService
}

Config for this controller

type Controller

type Controller interface {
	AddCocoNodePresence(c *gin.Context)
	AddMixNodePresence(c *gin.Context)
	Topology(c *gin.Context)
	RegisterRoutes(router *gin.Engine)
}

Controller is the presence controller interface

func New

func New(cfg Config) Controller

New constructor

type GatewayHostSanitizer

type GatewayHostSanitizer interface {
	Sanitize(models.GatewayHostInfo) models.GatewayHostInfo
}

GatewayHostSanitizer cleans untrusted input fields

type GatewaySanitizer

type GatewaySanitizer struct {
	// contains filtered or unexported fields
}

GatewaySanitizer kills untrusted input in GatewayHostInfo structs

func NewGatewaySanitizer

func NewGatewaySanitizer(p *bluemonday.Policy) GatewaySanitizer

NewGatewaySanitizer constructor...

func (*GatewaySanitizer) Sanitize

func (s *GatewaySanitizer) Sanitize(input models.GatewayHostInfo) models.GatewayHostInfo

Sanitize GatewayHostInfo input

type IDb

type IDb interface {
	AddCoco(models.CocoPresence)
	AddMix(models.MixNodePresence)
	AddMixProvider(models.MixProviderPresence)
	AddGateway(models.GatewayPresence)
	Allow(string)
	Disallow(string)
	ListDisallowed() []string
	Topology() models.Topology
}

IDb holds presence information

type IMixNodeIDSanitizer

type IMixNodeIDSanitizer interface {
	Sanitize(models.MixNodeID) models.MixNodeID
}

IMixNodeIDSanitizer cleans untrusted input fields

type IPAssigner

type IPAssigner interface {
	AssignIP(serverReportedIP string, selfReportedHost string) (string, error)
}

IPAssigner compares the realIP (taken from the incoming request to the controller) and the self-reported presence IP (taken from the presence report data), and tries to report a reasonable IP. Much like the trouble with SUVs detailed by Paul Graham (http://www.paulgraham.com/hundred.html), this is a gross solution to a gross problem.

In our case, the cause of hassle is that AWS servers: (a) don't allow applications hosted on them to determine what address they're binding to easily, because there are no "real" public IPs assigned, and (b) cause the application to explode if you attempt to bind to the public IP at all (private IPs do exist and can be bound to).

If we could, we'd always read from the incoming request - but this has another problem: incoming requests don't tell us which port the remote node is listening on. So we need to combine self-reported and real IP.

type IService

type IService interface {
	AddCocoNodePresence(info models.CocoHostInfo, ip string)
	AddMixNodePresence(info models.MixHostInfo)
	AddMixProviderPresence(info models.MixProviderHostInfo)
	AddGatewayPresence(info models.GatewayHostInfo)
	Allow(hostKey models.MixNodeID)
	Disallow(hostKey models.MixNodeID)
	ListDisallowed() []models.MixNodePresence
	Topology() models.Topology
}

IService defines the REST service interface for presence.

type MixHostSanitizer

type MixHostSanitizer interface {
	Sanitize(models.MixHostInfo) models.MixHostInfo
}

MixHostSanitizer cleans untrusted input fields

type MixNodeIDSanitizer

type MixNodeIDSanitizer struct {
	// contains filtered or unexported fields
}

MixNodeIDSanitizer kills untrusted input in CocoHostInfo structs

func NewMixnodeIDSanitizer

func NewMixnodeIDSanitizer(p *bluemonday.Policy) MixNodeIDSanitizer

NewMixnodeIDSanitizer ...

func (*MixNodeIDSanitizer) Sanitize

func (s *MixNodeIDSanitizer) Sanitize(input models.MixNodeID) models.MixNodeID

Sanitize MixNodeID input

type MixProviderHostSanitizer

type MixProviderHostSanitizer interface {
	Sanitize(models.MixProviderHostInfo) models.MixProviderHostInfo
}

MixProviderHostSanitizer cleans untrusted input fields

type MixnodeSanitizer

type MixnodeSanitizer struct {
	// contains filtered or unexported fields
}

MixnodeSanitizer kills untrusted input in MixHostInfo structs

func NewMixnodeSanitizer

func NewMixnodeSanitizer(p *bluemonday.Policy) MixnodeSanitizer

NewMixnodeSanitizer constructor...

func (*MixnodeSanitizer) Sanitize

func (s *MixnodeSanitizer) Sanitize(input models.MixHostInfo) models.MixHostInfo

Sanitize MixHostInfo input

type MixproviderSanitizer

type MixproviderSanitizer struct {
	// contains filtered or unexported fields
}

MixproviderSanitizer kills untrusted input in MixProviderHostInfo structs

func NewMixproviderSanitizer

func NewMixproviderSanitizer(p *bluemonday.Policy) MixproviderSanitizer

NewMixproviderSanitizer constructor...

func (*MixproviderSanitizer) Sanitize

func (s *MixproviderSanitizer) Sanitize(input models.MixProviderHostInfo) models.MixProviderHostInfo

Sanitize MixProviderHostInfo input