hp: add topology support

go/lib/topology/interface.go

@@ -87,7 +87,7 @@ type Topology interface {
 	UnderlayNextHop(ifID common.IFIDType) (*net.UDPAddr, bool)
 
 	// MakeHostInfos returns the underlay addresses of all services for the specified service type.
-	MakeHostInfos(st ServiceType) []net.UDPAddr
+	MakeHostInfos(st ServiceType) ([]net.UDPAddr, error)
 
 	// Gateways returns an array of all gateways.
 	Gateways() ([]GatewayInfo, error)
@@ -190,20 +190,18 @@ func (t *topologyS) UnderlayNextHop2(ifid common.IFIDType) (*net.UDPAddr, bool)
 	return copyUDPAddr(ifInfo.InternalAddr), true
 }
 
-func (t *topologyS) MakeHostInfos(st ServiceType) []net.UDPAddr {
+func (t *topologyS) MakeHostInfos(st ServiceType) ([]net.UDPAddr, error) {
 	var hostInfos []net.UDPAddr
-	addresses, err := t.Topology.GetAllTopoAddrs(st)
+	addresses, err := t.Topology.getAllTopoAddrs(st)
 	if err != nil {
-		// FIXME(lukedirtwalker): inform client about this:
-		// see https://github.com/scionproto/scion/issues/1673
-		return hostInfos
+		return nil, err
 	}
 	for _, a := range addresses {
 		if tmp := a.SCIONAddress; tmp != nil {
 			hostInfos = append(hostInfos, *tmp)
 		}
 	}
-	return hostInfos
+	return hostInfos, nil
 }
 
 func (t *topologyS) Core() bool {
@@ -339,7 +337,7 @@ func (t *topologyS) UnderlayMulticast(svc addr.HostSVC) ([]*net.UDPAddr, error)
 	if err != nil {
 		return nil, err
 	}
-	topoAddrs, err := t.Topology.GetAllTopoAddrs(st)
+	topoAddrs, err := t.Topology.getAllTopoAddrs(st)
 	if err != nil {
 		return nil, serrors.Wrap(addr.ErrUnsupportedSVCAddress, err, "svc", svc)
 	}

go/lib/topology/json/json.go

@@ -68,11 +68,13 @@ type Topology struct {
 	MTU            int    `json:"mtu"`
 	// Attributes are the primary AS attributes as described in
 	// https://github.com/scionproto/scion/blob/master/doc/ControlPlanePKI.md#primary-ases
-	Attributes       []Attribute             `json:"attributes"`
-	BorderRouters    map[string]*BRInfo      `json:"border_routers,omitempty"`
-	ControlService   map[string]*ServerInfo  `json:"control_service,omitempty"`
-	DiscoveryService map[string]*ServerInfo  `json:"discovery_service,omitempty"`
-	SIG              map[string]*GatewayInfo `json:"sigs,omitempty"`
+	Attributes          []Attribute             `json:"attributes"`
+	BorderRouters       map[string]*BRInfo      `json:"border_routers,omitempty"`
+	ControlService      map[string]*ServerInfo  `json:"control_service,omitempty"`
+	DiscoveryService    map[string]*ServerInfo  `json:"discovery_service,omitempty"`
+	HiddenSegmentLookup map[string]*ServerInfo  `json:"hidden_segment_lookup_service,omitempty"`
+	HiddenSegmentReg    map[string]*ServerInfo  `json:"hidden_segment_registration_service,omitempty"`
+	SIG                 map[string]*GatewayInfo `json:"sigs,omitempty"`
 }
 
 // ServerInfo contains the information for a SCION application running in the local AS.

go/lib/topology/servicetype.go

@@ -26,6 +26,8 @@ const (
 	Control
 	Discovery
 	Gateway
+	HiddenSegmentLookup
+	HiddenSegmentRegistration
 )
 
 func (t ServiceType) String() string {
@@ -38,6 +40,10 @@ func (t ServiceType) String() string {
 		return "discovery"
 	case Gateway:
 		return "gateway"
+	case HiddenSegmentLookup:
+		return "hiddensegmentlookup"
+	case HiddenSegmentRegistration:
+		return "hiddensegmentregistration"
 	default:
 		return "unknown"
 	}
@@ -54,6 +60,10 @@ func ServiceTypeFromString(s string) ServiceType {
 		return Discovery
 	case "gateway":
 		return Gateway
+	case "hiddensegmentlookup":
+		return HiddenSegmentLookup
+	case "hiddensegmentregistration":
+		return HiddenSegmentRegistration
 	default:
 		return Unknown
 	}

go/lib/topology/servicetype_test.go

@@ -29,6 +29,8 @@ func TestServiceTypeStringAndParse(t *testing.T) {
 		topology.Control,
 		topology.Discovery,
 		topology.Gateway,
+		topology.HiddenSegmentLookup,
+		topology.HiddenSegmentRegistration,
 	}
 	for _, st := range serviceTypes {
 		t.Run(st.String(), func(t *testing.T) {

go/lib/topology/topology.go

@@ -34,6 +34,9 @@ import (
 // EndhostPort is the underlay port that the dispatcher binds to on non-routers.
 const EndhostPort = underlay.EndhostPort
 
+// ErrAddressNotFound indicates the address was not found.
+var ErrAddressNotFound = serrors.New("address not found")
+
 type (
 	// RWTopology is the topology type for applications and libraries that need write
 	// access to AS topology information (e.g., discovery, topology reloaders).
@@ -64,9 +67,11 @@ type (
 		BRNames   []string
 		IFInfoMap IfInfoMap
 
-		CS  IDAddrMap
-		DS  IDAddrMap
-		SIG map[string]GatewayInfo
+		CS                        IDAddrMap
+		DS                        IDAddrMap
+		HiddenSegmentLookup       IDAddrMap
+		HiddenSegmentRegistration IDAddrMap
+		SIG                       map[string]GatewayInfo
 	}
 
 	// GatewayInfo describes a scion gateway.
@@ -137,11 +142,13 @@ type (
 // NewRWTopology creates new empty Topo object, including all possible service maps etc.
 func NewRWTopology() *RWTopology {
 	return &RWTopology{
-		BR:        make(map[string]BRInfo),
-		CS:        make(IDAddrMap),
-		DS:        make(IDAddrMap),
-		SIG:       make(map[string]GatewayInfo),
-		IFInfoMap: make(IfInfoMap),
+		BR:                        make(map[string]BRInfo),
+		CS:                        make(IDAddrMap),
+		DS:                        make(IDAddrMap),
+		HiddenSegmentLookup:       make(IDAddrMap),
+		HiddenSegmentRegistration: make(IDAddrMap),
+		SIG:                       make(map[string]GatewayInfo),
+		IFInfoMap:                 make(IfInfoMap),
 	}
 }
 
@@ -306,7 +313,14 @@ func (t *RWTopology) populateServices(raw *jsontopo.Topology) error {
 	if err != nil {
 		return serrors.WrapStr("unable to extract DS address", err)
 	}
-
+	t.HiddenSegmentLookup, err = svcMapFromRaw(raw.HiddenSegmentLookup)
+	if err != nil {
+		return serrors.WrapStr("unable to extract hidden segment lookup address", err)
+	}
+	t.HiddenSegmentRegistration, err = svcMapFromRaw(raw.HiddenSegmentReg)
+	if err != nil {
+		return serrors.WrapStr("unable to extract hidden segment registration address", err)
+	}
 	return nil
 }
 
@@ -330,15 +344,15 @@ func (t *RWTopology) GetTopoAddr(id string, svc ServiceType) (*TopoAddr, error)
 	return topoAddr, nil
 }
 
-// GetAllTopoAddrs returns the address information of all processes of the requested type.
-func (t *RWTopology) GetAllTopoAddrs(svc ServiceType) ([]TopoAddr, error) {
+// getAllTopoAddrs returns the address information of all processes of the requested type.
+func (t *RWTopology) getAllTopoAddrs(svc ServiceType) ([]TopoAddr, error) {
 	svcInfo, err := t.getSvcInfo(svc)
 	if err != nil {
 		return nil, err
 	}
 	topoAddrs := svcInfo.getAllTopoAddrs()
 	if topoAddrs == nil {
-		return nil, serrors.New("Address not found")
+		return nil, ErrAddressNotFound
 	}
 	return topoAddrs, nil
 }
@@ -351,6 +365,10 @@ func (t *RWTopology) getSvcInfo(svc ServiceType) (*svcInfo, error) {
 		return &svcInfo{idTopoAddrMap: t.DS}, nil
 	case Control:
 		return &svcInfo{idTopoAddrMap: t.CS}, nil
+	case HiddenSegmentLookup:
+		return &svcInfo{idTopoAddrMap: t.HiddenSegmentLookup}, nil
+	case HiddenSegmentRegistration:
+		return &svcInfo{idTopoAddrMap: t.HiddenSegmentRegistration}, nil
 	case Gateway:
 		m := make(IDAddrMap)
 		for k, v := range t.SIG {
@@ -377,9 +395,11 @@ func (t *RWTopology) Copy() *RWTopology {
 		BRNames:   append(t.BRNames[:0:0], t.BRNames...),
 		IFInfoMap: t.IFInfoMap.copy(),
 
-		CS:  t.CS.copy(),
-		DS:  t.DS.copy(),
-		SIG: copySIGMap(t.SIG),
+		CS:                        t.CS.copy(),
+		DS:                        t.DS.copy(),
+		SIG:                       copySIGMap(t.SIG),
+		HiddenSegmentLookup:       t.HiddenSegmentLookup.copy(),
+		HiddenSegmentRegistration: t.HiddenSegmentRegistration.copy(),
 	}
 }
 

go/pkg/discovery/BUILD.bazel

@@ -28,5 +28,6 @@ go_test(
         "//go/lib/topology:go_default_library",
         "//go/pkg/proto/discovery:go_default_library",
         "@com_github_stretchr_testify//assert:go_default_library",
+        "@com_github_stretchr_testify//require:go_default_library",
     ],
 )

go/pkg/discovery/testdata/topology.json

@@ -1,4 +1,4 @@
- {
+{
   "isd_as": "1-ff00:0:311",
   "sigs": {
     "sig1-ff00:0:311-1": {

go/pkg/discovery/toposervice.go

@@ -16,6 +16,7 @@ package discovery
 
 import (
 	"context"
+	"errors"
 	"net"
 
 	"github.com/opentracing/opentracing-go"
@@ -86,9 +87,32 @@ func (t Topology) HiddenSegmentServices(ctx context.Context,
 	labels := requestLabels{ReqType: "hidden_segment_services"}
 	logger := log.FromCtx(ctx)
 
-	logger.Debug("Hidden segment services currently not supported")
-	t.updateTelemetry(span, labels.WithResult("err_unimplemented"), nil)
-	return nil, status.Error(codes.Unimplemented, "not supported")
+	topo := t.Provider.Get()
+	lookups, err := topo.MakeHostInfos(topology.HiddenSegmentLookup)
+	if err != nil && !errors.Is(err, topology.ErrAddressNotFound) {
+		return nil, err
+	}
+	registration, err := topo.MakeHostInfos(topology.HiddenSegmentRegistration)
+	if err != nil && !errors.Is(err, topology.ErrAddressNotFound) {
+		return nil, err
+	}
+
+	response := &dpb.HiddenSegmentServicesResponse{}
+	for _, l := range lookups {
+		response.Lookup = append(response.Lookup, &dpb.HiddenSegmentLookupServer{
+			Address: l.String(),
+		})
+	}
+	for _, r := range registration {
+		response.Registration = append(response.Registration, &dpb.HiddenSegmentRegistrationServer{
+			Address: r.String(),
+		})
+	}
+
+	logger.Debug("Replied with hidden segment services",
+		"lookups", len(lookups), "registration", len(registration))
+	t.updateTelemetry(span, labels.WithResult(prom.Success), nil)
+	return response, nil
 }
 
 // RequestsLabels exposes the labels required by the Requests metric.