rctx

Documentation

Overview

Copyright 2017 ETH Zurich

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Package rctx holds the current router context. The context contains a conf object and slices of input and output functions.

Index

• func Set(newCtx *Ctx)
• type Ctx
  • func Get() *Ctx
  • func New(conf *conf.Conf) *Ctx
  • func (ctx *Ctx) GetSVCNamesMap(svc addr.HostSVC) ([]string, map[string]topology.TopoAddr, error)
  • func (ctx *Ctx) ResolveSVC(svc addr.HostSVC) ([]*overlay.OverlayAddr, error)
  • func (ctx *Ctx) ResolveSVCAny(svc addr.HostSVC) (*overlay.OverlayAddr, error)
  • func (ctx *Ctx) ResolveSVCMulti(svc addr.HostSVC) ([]*overlay.OverlayAddr, error)
• type Sock
  • func NewSock(ring *ringbuf.Ring, conn conn.Conn, dir rcmn.Dir, ifid common.IFIDType, ...) *Sock
  • func (s *Sock) Start()
  • func (s *Sock) Stop()
• type SockFunc

Functions

func Set

func Set(newCtx *Ctx)

Set updates the current router context.

Types

type Ctx

type Ctx struct {
	// Conf contains the router state for this context.
	Conf *conf.Conf
	// LockSockIn is a Sock for receiving packets from the local AS,
	LocSockIn *Sock
	// LocSockOut is a Sock for sending packets to the local AS,
	LocSockOut *Sock
	// ExtSockIn is a map of Sock's for receiving packets from neighbouring
	// ASes, keyed by the interface ID of the relevant link.
	ExtSockIn map[common.IFIDType]*Sock
	// ExtSockOut is a map of Sock's for sending packets to neighbouring ASes,
	// keyed by the interface ID of the relevant link.
	ExtSockOut map[common.IFIDType]*Sock
}

Ctx is the main router context structure.

func Get

func Get() *Ctx

Get returns a pointer to the current router context.

func New

func New(conf *conf.Conf) *Ctx

New returns a new Ctx instance.

func (*Ctx) GetSVCNamesMap

func (ctx *Ctx) GetSVCNamesMap(svc addr.HostSVC) ([]string,
	map[string]topology.TopoAddr, error)

GetSVCNamesMap returns the slice of instance names and addresses for a given SVC address.

func (*Ctx) ResolveSVC

func (ctx *Ctx) ResolveSVC(svc addr.HostSVC) ([]*overlay.OverlayAddr, error)

func (*Ctx) ResolveSVCAny

func (ctx *Ctx) ResolveSVCAny(svc addr.HostSVC) (*overlay.OverlayAddr, error)

ResolveSVCAny resolves an anycast SVC address (i.e. a single instance of a local infrastructure service).

func (*Ctx) ResolveSVCMulti

func (ctx *Ctx) ResolveSVCMulti(svc addr.HostSVC) ([]*overlay.OverlayAddr, error)

ResolveSVCMulti resovles a multicast SVC address (i.e. one packet per machine hosting instances for a local infrastructure service).

type Sock

type Sock struct {
	// Ring is a ring-buffer that's written to by writers, and read from by readers.
	Ring *ringbuf.Ring
	// Conn is the underlying connection that this Sock represents.
	Conn conn.Conn
	// Dir is the direction that a packet is being read from/written to.
	Dir rcmn.Dir
	// Ifid is the interface ID associated with a connection.
	Ifid common.IFIDType
	// Labels holds the exported prometheus labels.
	Labels prometheus.Labels
	// Reader is an optional function that reads from Sock.Ring. It is spawned
	// in a go routine when Sock.Start() is called.
	Reader SockFunc
	// Writer is an optional function that writes to Sock.Ring. It is spawned
	// in a go routine when Sock.Start() is called.
	Writer SockFunc
	// contains filtered or unexported fields
}

Sock represents one direction of data-flow from an underlying connection. Each connection will have 2 Sock's associated, one for reading data from the network, the other for writing data to the network.

func NewSock

func NewSock(ring *ringbuf.Ring, conn conn.Conn, dir rcmn.Dir,
	ifid common.IFIDType, labels prometheus.Labels, reader, writer SockFunc) *Sock

func (*Sock) Start

func (s *Sock) Start()

Start starts the reader/writer goroutines (if any). Does nothing if they have been started already.

func (*Sock) Stop

func (s *Sock) Stop()

Stop stops the running reader/writer goroutines (if any) and waits until the routines are stopped before returing to the caller.

type SockFunc

type SockFunc func(sock *Sock, stop, stopped chan struct{})

SockFunc is a function that is started as a goroutine by Sock.Start()/Sock.Stop() to read/write to the underlying connection.