Addressed comments.
Change-Id: I1cca2eaf9f5357061acfb9e23000f677526a1762
diff --git a/go/src/examples/advertiser/advertiser.go b/go/src/examples/advertiser/advertiser.go
index bd05870..0d04f68 100644
--- a/go/src/examples/advertiser/advertiser.go
+++ b/go/src/examples/advertiser/advertiser.go
@@ -4,8 +4,8 @@
"log"
"mojo/public/go/application"
- "mojo/public/go/system"
"mojo/public/go/bindings"
+ "mojo/public/go/system"
"mojom/vanadium/discovery"
)
@@ -14,21 +14,21 @@
import "C"
type advDelegate struct {
- id int32
- proxy *discovery.Discoverer_Proxy
+ id int32
+ proxy *discovery.Advertiser_Proxy
}
func (a *advDelegate) Initialize(ctx application.Context) {
- req, ptr := discovery.CreateMessagePipeForDiscoverer()
+ req, ptr := discovery.CreateMessagePipeForAdvertiser()
ctx.ConnectToApplication("https://mojo.v.io/discovery.mojo").ConnectToService(&req)
- a.proxy = discovery.NewDiscovererProxy(ptr, bindings.GetAsyncWaiter())
+ a.proxy = discovery.NewAdvertiserProxy(ptr, bindings.GetAsyncWaiter())
s := discovery.Service{
InterfaceName: "v.io/discovery.T",
- Addrs: []string{"localhost:1000", "localhost:2000"},
- Attrs: map[string]string{ "foo" : "bar"},
+ Addrs: []string{"localhost:1000", "localhost:2000"},
+ Attrs: map[string]string{"foo": "bar"},
}
id, e1, e2 := a.proxy.Advertise(s, nil)
- if e1 != nil || e2 != nil{
+ if e1 != nil || e2 != nil {
log.Println("Error occurred", e1, e2)
return
}
@@ -36,7 +36,6 @@
a.id = id
}
-
func (*advDelegate) AcceptConnection(connection *application.Connection) {
connection.Close()
}
@@ -45,7 +44,6 @@
s.proxy.StopAdvertising(s.id)
}
-
//export MojoMain
func MojoMain(handle C.MojoHandle) C.MojoResult {
application.Run(&advDelegate{}, system.MojoHandle(handle))
diff --git a/go/src/examples/scanner/scanner.go b/go/src/examples/scanner/scanner.go
index 6c749fe..60ed6d9 100644
--- a/go/src/examples/scanner/scanner.go
+++ b/go/src/examples/scanner/scanner.go
@@ -4,8 +4,8 @@
"log"
"mojo/public/go/application"
- "mojo/public/go/system"
"mojo/public/go/bindings"
+ "mojo/public/go/system"
"mojom/vanadium/discovery"
)
@@ -13,7 +13,7 @@
//#include "mojo/public/c/system/types.h"
import "C"
-type handler struct {}
+type handler struct{}
func (*handler) Found(s discovery.Service) error {
log.Println("Found a new service", s)
@@ -26,19 +26,19 @@
}
type scannerDelegate struct {
- id int32
- proxy *discovery.Discoverer_Proxy
- stub *bindings.Stub
+ id int32
+ proxy *discovery.Scanner_Proxy
+ stub *bindings.Stub
}
func (s *scannerDelegate) Initialize(ctx application.Context) {
- req, ptr := discovery.CreateMessagePipeForDiscoverer()
+ req, ptr := discovery.CreateMessagePipeForScanner()
ctx.ConnectToApplication("https://mojo.v.io/discovery.mojo").ConnectToService(&req)
- s.proxy = discovery.NewDiscovererProxy(ptr, bindings.GetAsyncWaiter())
+ s.proxy = discovery.NewScannerProxy(ptr, bindings.GetAsyncWaiter())
scanReq, scanPtr := discovery.CreateMessagePipeForScanHandler()
s.stub = discovery.NewScanHandlerStub(scanReq, &handler{}, bindings.GetAsyncWaiter())
id, e1, e2 := s.proxy.Scan("v.io/discovery.T", scanPtr)
- if e1 != nil || e2 != nil{
+ if e1 != nil || e2 != nil {
log.Println("Error occurred", e1, e2)
return
}
@@ -57,7 +57,6 @@
}()
}
-
func (*scannerDelegate) AcceptConnection(connection *application.Connection) {
connection.Close()
}
@@ -67,7 +66,6 @@
s.stub.Close()
}
-
//export MojoMain
func MojoMain(handle C.MojoHandle) C.MojoResult {
application.Run(&scannerDelegate{}, system.MojoHandle(handle))
diff --git a/go/src/mojom/vanadium/discovery/discovery.mojom.go b/go/src/mojom/vanadium/discovery/discovery.mojom.go
index 3caf89c..458c651 100644
--- a/go/src/mojom/vanadium/discovery/discovery.mojom.go
+++ b/go/src/mojom/vanadium/discovery/discovery.mojom.go
@@ -17,78 +17,74 @@
"sort"
)
-type Discoverer interface {
+type Advertiser interface {
Advertise(inS Service, inPattern []string) (outHandle int32, outErr *Error, err error)
StopAdvertising(inH int32) (err error)
- Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle int32, outErr *Error, err error)
- StopScan(inH int32) (err error)
}
-var discoverer_Name = "discovery::Discoverer"
+var advertiser_Name = "discovery::Advertiser"
-type Discoverer_Request bindings.InterfaceRequest
+type Advertiser_Request bindings.InterfaceRequest
-func (r *Discoverer_Request) Name() string {
- return discoverer_Name
+func (r *Advertiser_Request) Name() string {
+ return advertiser_Name
}
-type Discoverer_Pointer bindings.InterfacePointer
+type Advertiser_Pointer bindings.InterfacePointer
-func (p *Discoverer_Pointer) Name() string {
- return discoverer_Name
+func (p *Advertiser_Pointer) Name() string {
+ return advertiser_Name
}
-type Discoverer_ServiceFactory struct {
- Delegate Discoverer_Factory
+type Advertiser_ServiceFactory struct {
+ Delegate Advertiser_Factory
}
-type Discoverer_Factory interface {
- Create(request Discoverer_Request)
+type Advertiser_Factory interface {
+ Create(request Advertiser_Request)
}
-func (f *Discoverer_ServiceFactory) Name() string {
- return discoverer_Name
+func (f *Advertiser_ServiceFactory) Name() string {
+ return advertiser_Name
}
-func (f *Discoverer_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
- request := Discoverer_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
+func (f *Advertiser_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
+ request := Advertiser_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
f.Delegate.Create(request)
}
-// CreateMessagePipeForDiscoverer creates a message pipe for use with the
-// Discoverer interface with a Discoverer_Request on one end and a Discoverer_Pointer on the other.
-func CreateMessagePipeForDiscoverer() (Discoverer_Request, Discoverer_Pointer) {
+// CreateMessagePipeForAdvertiser creates a message pipe for use with the
+// Advertiser interface with a Advertiser_Request on one end and a Advertiser_Pointer on the other.
+func CreateMessagePipeForAdvertiser() (Advertiser_Request, Advertiser_Pointer) {
r, p := bindings.CreateMessagePipeForMojoInterface()
- return Discoverer_Request(r), Discoverer_Pointer(p)
+ return Advertiser_Request(r), Advertiser_Pointer(p)
}
-const discoverer_Advertise_Name uint32 = 0
-const discoverer_StopAdvertising_Name uint32 = 1
-const discoverer_Scan_Name uint32 = 2
-const discoverer_StopScan_Name uint32 = 3
+const advertiser_Advertise_Name uint32 = 0
+const advertiser_StopAdvertising_Name uint32 = 1
-type Discoverer_Proxy struct {
+type Advertiser_Proxy struct {
router *bindings.Router
ids bindings.Counter
}
-func NewDiscovererProxy(p Discoverer_Pointer, waiter bindings.AsyncWaiter) *Discoverer_Proxy {
- return &Discoverer_Proxy{
+func NewAdvertiserProxy(p Advertiser_Pointer, waiter bindings.AsyncWaiter) *Advertiser_Proxy {
+ return &Advertiser_Proxy{
bindings.NewRouter(p.PassMessagePipe(), waiter),
bindings.NewCounter(),
}
}
-func (p *Discoverer_Proxy) Close_Proxy() {
+func (p *Advertiser_Proxy) Close_Proxy() {
p.router.Close()
}
-type discoverer_Advertise_Params struct {
+type advertiser_Advertise_Params struct {
inS Service
inPattern []string
}
-func (s *discoverer_Advertise_Params) Encode(encoder *bindings.Encoder) error {
+func (s *advertiser_Advertise_Params) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(16, 0)
if err := encoder.WritePointer(); err != nil {
return err
@@ -117,23 +113,23 @@
return nil
}
-var discoverer_Advertise_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var advertiser_Advertise_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{24, 0},
}
-func (s *discoverer_Advertise_Params) Decode(decoder *bindings.Decoder) error {
+func (s *advertiser_Advertise_Params) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
- index := sort.Search(len(discoverer_Advertise_Params_Versions), func(i int) bool {
- return discoverer_Advertise_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ index := sort.Search(len(advertiser_Advertise_Params_Versions), func(i int) bool {
+ return advertiser_Advertise_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
- if index < len(discoverer_Advertise_Params_Versions) {
- if discoverer_Advertise_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ if index < len(advertiser_Advertise_Params_Versions) {
+ if advertiser_Advertise_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
- expectedSize := discoverer_Advertise_Params_Versions[index].Size
+ expectedSize := advertiser_Advertise_Params_Versions[index].Size
if expectedSize != header.Size {
return &bindings.ValidationError{bindings.UnexpectedStructHeader,
fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -192,12 +188,12 @@
return nil
}
-type discoverer_Advertise_ResponseParams struct {
+type advertiser_Advertise_ResponseParams struct {
outHandle int32
outErr *Error
}
-func (s *discoverer_Advertise_ResponseParams) Encode(encoder *bindings.Encoder) error {
+func (s *advertiser_Advertise_ResponseParams) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(16, 0)
if err := encoder.WriteInt32(s.outHandle); err != nil {
return err
@@ -218,23 +214,23 @@
return nil
}
-var discoverer_Advertise_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+var advertiser_Advertise_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{24, 0},
}
-func (s *discoverer_Advertise_ResponseParams) Decode(decoder *bindings.Decoder) error {
+func (s *advertiser_Advertise_ResponseParams) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
- index := sort.Search(len(discoverer_Advertise_ResponseParams_Versions), func(i int) bool {
- return discoverer_Advertise_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ index := sort.Search(len(advertiser_Advertise_ResponseParams_Versions), func(i int) bool {
+ return advertiser_Advertise_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
- if index < len(discoverer_Advertise_ResponseParams_Versions) {
- if discoverer_Advertise_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ if index < len(advertiser_Advertise_ResponseParams_Versions) {
+ if advertiser_Advertise_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
- expectedSize := discoverer_Advertise_ResponseParams_Versions[index].Size
+ expectedSize := advertiser_Advertise_ResponseParams_Versions[index].Size
if expectedSize != header.Size {
return &bindings.ValidationError{bindings.UnexpectedStructHeader,
fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -268,13 +264,13 @@
return nil
}
-func (p *Discoverer_Proxy) Advertise(inS Service, inPattern []string) (outHandle int32, outErr *Error, err error) {
- payload := &discoverer_Advertise_Params{
+func (p *Advertiser_Proxy) Advertise(inS Service, inPattern []string) (outHandle int32, outErr *Error, err error) {
+ payload := &advertiser_Advertise_Params{
inS,
inPattern,
}
header := bindings.MessageHeader{
- Type: discoverer_Advertise_Name,
+ Type: advertiser_Advertise_Name,
Flags: bindings.MessageExpectsResponseFlag,
RequestId: p.ids.Count(),
}
@@ -295,13 +291,13 @@
}
return
}
- if got, want := readResult.Message.Header.Type, discoverer_Advertise_Name; got != want {
+ if got, want := readResult.Message.Header.Type, advertiser_Advertise_Name; got != want {
err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
}
return
}
- var response discoverer_Advertise_ResponseParams
+ var response advertiser_Advertise_ResponseParams
if err = readResult.Message.DecodePayload(&response); err != nil {
p.Close_Proxy()
return
@@ -311,11 +307,11 @@
return
}
-type discoverer_StopAdvertising_Params struct {
+type advertiser_StopAdvertising_Params struct {
inH int32
}
-func (s *discoverer_StopAdvertising_Params) Encode(encoder *bindings.Encoder) error {
+func (s *advertiser_StopAdvertising_Params) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(8, 0)
if err := encoder.WriteInt32(s.inH); err != nil {
return err
@@ -326,23 +322,23 @@
return nil
}
-var discoverer_StopAdvertising_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var advertiser_StopAdvertising_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{16, 0},
}
-func (s *discoverer_StopAdvertising_Params) Decode(decoder *bindings.Decoder) error {
+func (s *advertiser_StopAdvertising_Params) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
- index := sort.Search(len(discoverer_StopAdvertising_Params_Versions), func(i int) bool {
- return discoverer_StopAdvertising_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ index := sort.Search(len(advertiser_StopAdvertising_Params_Versions), func(i int) bool {
+ return advertiser_StopAdvertising_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
- if index < len(discoverer_StopAdvertising_Params_Versions) {
- if discoverer_StopAdvertising_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ if index < len(advertiser_StopAdvertising_Params_Versions) {
+ if advertiser_StopAdvertising_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
- expectedSize := discoverer_StopAdvertising_Params_Versions[index].Size
+ expectedSize := advertiser_StopAdvertising_Params_Versions[index].Size
if expectedSize != header.Size {
return &bindings.ValidationError{bindings.UnexpectedStructHeader,
fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -362,12 +358,12 @@
return nil
}
-func (p *Discoverer_Proxy) StopAdvertising(inH int32) (err error) {
- payload := &discoverer_StopAdvertising_Params{
+func (p *Advertiser_Proxy) StopAdvertising(inH int32) (err error) {
+ payload := &advertiser_StopAdvertising_Params{
inH,
}
header := bindings.MessageHeader{
- Type: discoverer_StopAdvertising_Name,
+ Type: advertiser_StopAdvertising_Name,
Flags: bindings.MessageNoFlag,
}
var message *bindings.Message
@@ -383,12 +379,134 @@
return
}
-type discoverer_Scan_Params struct {
+type advertiser_Stub struct {
+ connector *bindings.Connector
+ impl Advertiser
+}
+
+func NewAdvertiserStub(r Advertiser_Request, impl Advertiser, waiter bindings.AsyncWaiter) *bindings.Stub {
+ connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
+ return bindings.NewStub(connector, &advertiser_Stub{connector, impl})
+}
+
+func (s *advertiser_Stub) Accept(message *bindings.Message) (err error) {
+ switch message.Header.Type {
+ case advertiser_Advertise_Name:
+ if message.Header.Flags != bindings.MessageExpectsResponseFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request advertiser_Advertise_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ var response advertiser_Advertise_ResponseParams
+ response.outHandle, response.outErr, err = s.impl.Advertise(request.inS, request.inPattern)
+ if err != nil {
+ return
+ }
+ header := bindings.MessageHeader{
+ Type: advertiser_Advertise_Name,
+ Flags: bindings.MessageIsResponseFlag,
+ RequestId: message.Header.RequestId,
+ }
+ message, err = bindings.EncodeMessage(header, &response)
+ if err != nil {
+ return err
+ }
+ return s.connector.WriteMessage(message)
+ case advertiser_StopAdvertising_Name:
+ if message.Header.Flags != bindings.MessageNoFlag {
+ return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+ fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+ }
+ }
+ var request advertiser_StopAdvertising_Params
+ if err := message.DecodePayload(&request); err != nil {
+ return err
+ }
+ err = s.impl.StopAdvertising(request.inH)
+ if err != nil {
+ return
+ }
+ default:
+ return &bindings.ValidationError{
+ bindings.MessageHeaderUnknownMethod,
+ fmt.Sprintf("unknown method %v", message.Header.Type),
+ }
+ }
+ return
+}
+
+type Scanner interface {
+ Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle int32, outErr *Error, err error)
+ StopScan(inH int32) (err error)
+}
+
+var scanner_Name = "discovery::Scanner"
+
+type Scanner_Request bindings.InterfaceRequest
+
+func (r *Scanner_Request) Name() string {
+ return scanner_Name
+}
+
+type Scanner_Pointer bindings.InterfacePointer
+
+func (p *Scanner_Pointer) Name() string {
+ return scanner_Name
+}
+
+type Scanner_ServiceFactory struct {
+ Delegate Scanner_Factory
+}
+
+type Scanner_Factory interface {
+ Create(request Scanner_Request)
+}
+
+func (f *Scanner_ServiceFactory) Name() string {
+ return scanner_Name
+}
+
+func (f *Scanner_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
+ request := Scanner_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
+ f.Delegate.Create(request)
+}
+
+// CreateMessagePipeForScanner creates a message pipe for use with the
+// Scanner interface with a Scanner_Request on one end and a Scanner_Pointer on the other.
+func CreateMessagePipeForScanner() (Scanner_Request, Scanner_Pointer) {
+ r, p := bindings.CreateMessagePipeForMojoInterface()
+ return Scanner_Request(r), Scanner_Pointer(p)
+}
+
+const scanner_Scan_Name uint32 = 0
+const scanner_StopScan_Name uint32 = 1
+
+type Scanner_Proxy struct {
+ router *bindings.Router
+ ids bindings.Counter
+}
+
+func NewScannerProxy(p Scanner_Pointer, waiter bindings.AsyncWaiter) *Scanner_Proxy {
+ return &Scanner_Proxy{
+ bindings.NewRouter(p.PassMessagePipe(), waiter),
+ bindings.NewCounter(),
+ }
+}
+
+func (p *Scanner_Proxy) Close_Proxy() {
+ p.router.Close()
+}
+
+type scanner_Scan_Params struct {
inQuery string
inScanHandler ScanHandler_Pointer
}
-func (s *discoverer_Scan_Params) Encode(encoder *bindings.Encoder) error {
+func (s *scanner_Scan_Params) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(16, 0)
if err := encoder.WritePointer(); err != nil {
return err
@@ -405,23 +523,23 @@
return nil
}
-var discoverer_Scan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var scanner_Scan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{24, 0},
}
-func (s *discoverer_Scan_Params) Decode(decoder *bindings.Decoder) error {
+func (s *scanner_Scan_Params) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
- index := sort.Search(len(discoverer_Scan_Params_Versions), func(i int) bool {
- return discoverer_Scan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ index := sort.Search(len(scanner_Scan_Params_Versions), func(i int) bool {
+ return scanner_Scan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
- if index < len(discoverer_Scan_Params_Versions) {
- if discoverer_Scan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ if index < len(scanner_Scan_Params_Versions) {
+ if scanner_Scan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
- expectedSize := discoverer_Scan_Params_Versions[index].Size
+ expectedSize := scanner_Scan_Params_Versions[index].Size
if expectedSize != header.Size {
return &bindings.ValidationError{bindings.UnexpectedStructHeader,
fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -461,12 +579,12 @@
return nil
}
-type discoverer_Scan_ResponseParams struct {
+type scanner_Scan_ResponseParams struct {
outHandle int32
outErr *Error
}
-func (s *discoverer_Scan_ResponseParams) Encode(encoder *bindings.Encoder) error {
+func (s *scanner_Scan_ResponseParams) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(16, 0)
if err := encoder.WriteInt32(s.outHandle); err != nil {
return err
@@ -487,23 +605,23 @@
return nil
}
-var discoverer_Scan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+var scanner_Scan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{24, 0},
}
-func (s *discoverer_Scan_ResponseParams) Decode(decoder *bindings.Decoder) error {
+func (s *scanner_Scan_ResponseParams) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
- index := sort.Search(len(discoverer_Scan_ResponseParams_Versions), func(i int) bool {
- return discoverer_Scan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ index := sort.Search(len(scanner_Scan_ResponseParams_Versions), func(i int) bool {
+ return scanner_Scan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
- if index < len(discoverer_Scan_ResponseParams_Versions) {
- if discoverer_Scan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ if index < len(scanner_Scan_ResponseParams_Versions) {
+ if scanner_Scan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
- expectedSize := discoverer_Scan_ResponseParams_Versions[index].Size
+ expectedSize := scanner_Scan_ResponseParams_Versions[index].Size
if expectedSize != header.Size {
return &bindings.ValidationError{bindings.UnexpectedStructHeader,
fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -537,13 +655,13 @@
return nil
}
-func (p *Discoverer_Proxy) Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle int32, outErr *Error, err error) {
- payload := &discoverer_Scan_Params{
+func (p *Scanner_Proxy) Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle int32, outErr *Error, err error) {
+ payload := &scanner_Scan_Params{
inQuery,
inScanHandler,
}
header := bindings.MessageHeader{
- Type: discoverer_Scan_Name,
+ Type: scanner_Scan_Name,
Flags: bindings.MessageExpectsResponseFlag,
RequestId: p.ids.Count(),
}
@@ -564,13 +682,13 @@
}
return
}
- if got, want := readResult.Message.Header.Type, discoverer_Scan_Name; got != want {
+ if got, want := readResult.Message.Header.Type, scanner_Scan_Name; got != want {
err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
}
return
}
- var response discoverer_Scan_ResponseParams
+ var response scanner_Scan_ResponseParams
if err = readResult.Message.DecodePayload(&response); err != nil {
p.Close_Proxy()
return
@@ -580,11 +698,11 @@
return
}
-type discoverer_StopScan_Params struct {
+type scanner_StopScan_Params struct {
inH int32
}
-func (s *discoverer_StopScan_Params) Encode(encoder *bindings.Encoder) error {
+func (s *scanner_StopScan_Params) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(8, 0)
if err := encoder.WriteInt32(s.inH); err != nil {
return err
@@ -595,23 +713,23 @@
return nil
}
-var discoverer_StopScan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var scanner_StopScan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{16, 0},
}
-func (s *discoverer_StopScan_Params) Decode(decoder *bindings.Decoder) error {
+func (s *scanner_StopScan_Params) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
- index := sort.Search(len(discoverer_StopScan_Params_Versions), func(i int) bool {
- return discoverer_StopScan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+ index := sort.Search(len(scanner_StopScan_Params_Versions), func(i int) bool {
+ return scanner_StopScan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
- if index < len(discoverer_StopScan_Params_Versions) {
- if discoverer_StopScan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+ if index < len(scanner_StopScan_Params_Versions) {
+ if scanner_StopScan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
- expectedSize := discoverer_StopScan_Params_Versions[index].Size
+ expectedSize := scanner_StopScan_Params_Versions[index].Size
if expectedSize != header.Size {
return &bindings.ValidationError{bindings.UnexpectedStructHeader,
fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -631,12 +749,12 @@
return nil
}
-func (p *Discoverer_Proxy) StopScan(inH int32) (err error) {
- payload := &discoverer_StopScan_Params{
+func (p *Scanner_Proxy) StopScan(inH int32) (err error) {
+ payload := &scanner_StopScan_Params{
inH,
}
header := bindings.MessageHeader{
- Type: discoverer_StopScan_Name,
+ Type: scanner_StopScan_Name,
Flags: bindings.MessageNoFlag,
}
var message *bindings.Message
@@ -652,74 +770,35 @@
return
}
-type discoverer_Stub struct {
+type scanner_Stub struct {
connector *bindings.Connector
- impl Discoverer
+ impl Scanner
}
-func NewDiscovererStub(r Discoverer_Request, impl Discoverer, waiter bindings.AsyncWaiter) *bindings.Stub {
+func NewScannerStub(r Scanner_Request, impl Scanner, waiter bindings.AsyncWaiter) *bindings.Stub {
connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
- return bindings.NewStub(connector, &discoverer_Stub{connector, impl})
+ return bindings.NewStub(connector, &scanner_Stub{connector, impl})
}
-func (s *discoverer_Stub) Accept(message *bindings.Message) (err error) {
+func (s *scanner_Stub) Accept(message *bindings.Message) (err error) {
switch message.Header.Type {
- case discoverer_Advertise_Name:
+ case scanner_Scan_Name:
if message.Header.Flags != bindings.MessageExpectsResponseFlag {
return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
}
}
- var request discoverer_Advertise_Params
+ var request scanner_Scan_Params
if err := message.DecodePayload(&request); err != nil {
return err
}
- var response discoverer_Advertise_ResponseParams
- response.outHandle, response.outErr, err = s.impl.Advertise(request.inS, request.inPattern)
- if err != nil {
- return
- }
- header := bindings.MessageHeader{
- Type: discoverer_Advertise_Name,
- Flags: bindings.MessageIsResponseFlag,
- RequestId: message.Header.RequestId,
- }
- message, err = bindings.EncodeMessage(header, &response)
- if err != nil {
- return err
- }
- return s.connector.WriteMessage(message)
- case discoverer_StopAdvertising_Name:
- if message.Header.Flags != bindings.MessageNoFlag {
- return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
- fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
- }
- }
- var request discoverer_StopAdvertising_Params
- if err := message.DecodePayload(&request); err != nil {
- return err
- }
- err = s.impl.StopAdvertising(request.inH)
- if err != nil {
- return
- }
- case discoverer_Scan_Name:
- if message.Header.Flags != bindings.MessageExpectsResponseFlag {
- return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
- fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
- }
- }
- var request discoverer_Scan_Params
- if err := message.DecodePayload(&request); err != nil {
- return err
- }
- var response discoverer_Scan_ResponseParams
+ var response scanner_Scan_ResponseParams
response.outHandle, response.outErr, err = s.impl.Scan(request.inQuery, request.inScanHandler)
if err != nil {
return
}
header := bindings.MessageHeader{
- Type: discoverer_Scan_Name,
+ Type: scanner_Scan_Name,
Flags: bindings.MessageIsResponseFlag,
RequestId: message.Header.RequestId,
}
@@ -728,13 +807,13 @@
return err
}
return s.connector.WriteMessage(message)
- case discoverer_StopScan_Name:
+ case scanner_StopScan_Name:
if message.Header.Flags != bindings.MessageNoFlag {
return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
}
}
- var request discoverer_StopScan_Params
+ var request scanner_StopScan_Params
if err := message.DecodePayload(&request); err != nil {
return err
}
diff --git a/go/src/vanadium/discovery/discovery.go b/go/src/vanadium/discovery/discovery.go
index 7c4a2d2..f15ce4d 100644
--- a/go/src/vanadium/discovery/discovery.go
+++ b/go/src/vanadium/discovery/discovery.go
@@ -1,8 +1,6 @@
package main
import (
- "log"
-
"v.io/v23"
idiscovery "v.io/x/ref/lib/discovery"
"v.io/x/ref/lib/discovery/plugins/ble"
@@ -16,44 +14,58 @@
"mojo/public/go/application"
"mojo/public/go/bindings"
"mojo/public/go/system"
+ "v.io/v23/context"
)
//#include "mojo/public/c/system/types.h"
import "C"
type discoveryDelegate struct {
+ ctx *context.T
stubs []*bindings.Stub
impl *internal.DiscoveryService
shutdown v23.Shutdown
}
func (d *discoveryDelegate) Initialize(c application.Context) {
+ // TODO(bjornick): Caling init multiple times in the same process
+ // will be bad. For now, this is ok because this is the only
+ // vanadium service that will be used in the demos and each go library
+ // will be in its own process.
ctx, shutdown := v23.Init()
host := c.Args()[1]
- log.Println("Starting discovery with name", host)
+ ctx.Info("Starting discovery with name", host)
mplugin, err := mdns.New(host)
+ pluginList := []idiscovery.Plugin{}
if err != nil {
- log.Println("Failed to start mplugin", err)
+ ctx.Error("Failed to start MDNS plugin", err)
+ } else {
+ pluginList = append(pluginList, mplugin)
}
bplugin, err := ble.NewPlugin(host)
if err != nil {
- log.Println("Failed to start bplugin", err)
+ ctx.Error("Failed to start BLE plugin", err)
+ } else {
+ pluginList = append(pluginList, bplugin)
}
- d.impl = internal.NewDiscoveryService(ctx, idiscovery.New([]idiscovery.Plugin{mplugin, bplugin}))
+ if len(pluginList) == 0 {
+ c.Close()
+ return
+ }
+ d.impl = internal.NewDiscoveryService(ctx, idiscovery.New(pluginList))
d.shutdown = shutdown
}
-func (d *discoveryDelegate) Create(request mojom.Discoverer_Request) {
- stub := mojom.NewDiscovererStub(request, d.impl, bindings.GetAsyncWaiter())
+func (d *discoveryDelegate) addAndServeStub(stub *bindings.Stub) {
d.stubs = append(d.stubs, stub)
go func() {
for {
if err := stub.ServeRequest(); err != nil {
connectionErr, ok := err.(*bindings.ConnectionError)
if !ok || !connectionErr.Closed() {
- log.Println(err)
+ d.ctx.Error(err)
}
break
}
@@ -61,8 +73,28 @@
}()
}
+type advertiseFactory struct {
+ d *discoveryDelegate
+}
+
+func (a *advertiseFactory) Create(request mojom.Advertiser_Request) {
+ stub := mojom.NewAdvertiserStub(request, a.d.impl, bindings.GetAsyncWaiter())
+ a.d.addAndServeStub(stub)
+}
+
+type scannerFactory struct {
+ d *discoveryDelegate
+}
+
+func (s *scannerFactory) Create(request mojom.Scanner_Request) {
+ stub := mojom.NewScannerStub(request, s.d.impl, bindings.GetAsyncWaiter())
+ s.d.addAndServeStub(stub)
+}
+
func (d *discoveryDelegate) AcceptConnection(connection *application.Connection) {
- connection.ProvideServices(&mojom.Discoverer_ServiceFactory{d})
+ advFactory := &advertiseFactory{d: d}
+ scanFactory := scannerFactory{d: d}
+ connection.ProvideServices(&mojom.Advertiser_ServiceFactory{advFactory}, &mojom.ScanHandler_ServiceFactory{scanFactory})
}
func (d *discoveryDelegate) Quit() {
diff --git a/go/src/vanadium/discovery/internal/discovery.go b/go/src/vanadium/discovery/internal/discovery.go
index 9b4cd17..fe50d66 100644
--- a/go/src/vanadium/discovery/internal/discovery.go
+++ b/go/src/vanadium/discovery/internal/discovery.go
@@ -6,7 +6,6 @@
"v.io/v23/context"
"v.io/v23/discovery"
"v.io/v23/verror"
- idiscovery "v.io/x/ref/lib/discovery"
"mojo/public/go/bindings"
mojom "mojom/vanadium/discovery"
@@ -15,35 +14,28 @@
// DiscoveryService implements the mojom interface mojom/vanadium/discovery.DiscoveryService. It
// is basically a thin wrapper around the Vanadium Discovery API.
type DiscoveryService struct {
- ctx *context.T
- s discovery.T
- trigger *idiscovery.Trigger
+ ctx *context.T
+ s discovery.T
// mu protects pending* and next*
- mu sync.Mutex
+ mu sync.Mutex
// The id to assign the next advertisement.
- nextAdv int32
- // A map of advertisement ids to the cancellation channel. When StopAdvertisement is
- // called, the channel will be closed.
- pendingAdvs map[int32]chan struct{}
+ nextAdv int32
+ // A map of advertisement ids to the cancellation function.
+ activeAdvs map[int32]func()
// The id to assign to the next scan.
- nextScan int32
- // A map of scan id to the cancellataion channel. When StopScan is called, the channel
- // for that id will be closed.
- pendingScans map[int32]chan struct{}
+ nextScan int32
+ // A map of scan id to the cancellataion func()
+ activeScans map[int32]func()
}
-func convertToErrorStruct(err error) *mojom.Error {
- outErr := &mojom.Error{
- Id: "v.io/verror/Unknown",
+func v2mError(err error) *mojom.Error {
+ return &mojom.Error{
+ Id: string(verror.ErrorID(err)),
+ Action: int32(verror.Action(err)),
Msg: err.Error(),
}
- if e, ok := err.(verror.E); ok {
- outErr.Id = string(e.ID)
- outErr.Action = int32(e.Action)
- }
- return outErr
}
// NewDiscoveryService returns a new DiscoveryService bound to the context and the Vanadium
@@ -52,9 +44,8 @@
return &DiscoveryService{
ctx: ctx,
s: vDiscovery,
- trigger: idiscovery.NewTrigger(),
- pendingAdvs: map[int32]chan struct{}{},
- pendingScans: map[int32]chan struct{}{},
+ activeAdvs: map[int32]func(){},
+ activeScans: map[int32]func(){},
}
}
@@ -68,35 +59,34 @@
Addrs: s.Addrs,
}
- ctx, c := context.WithCancel(d.ctx)
+ ctx, cancel := context.WithCancel(d.ctx)
err := d.s.Advertise(ctx, vService, nil)
if err != nil {
- return 0, convertToErrorStruct(err), nil
+ cancel()
+ return 0, v2mError(err), nil
}
- ch := make(chan struct{})
d.mu.Lock()
id := d.nextAdv
- d.pendingAdvs[id] = ch
+ d.activeAdvs[id] = cancel
d.nextAdv++
d.mu.Unlock()
- d.trigger.Add(c, ch)
return id, nil, nil
}
// StopAdvertising stops advertising for the given advertising id.
func (d *DiscoveryService) StopAdvertising(handle int32) error {
d.mu.Lock()
- ch := d.pendingAdvs[handle]
- delete(d.pendingAdvs, handle)
+ cancel := d.activeAdvs[handle]
+ delete(d.activeAdvs, handle)
d.mu.Unlock()
- if ch != nil {
- close(ch)
+ if cancel != nil {
+ cancel()
}
return nil
}
-func vServiceTomService(s discovery.Service) mojom.Service {
+func v2mService(s discovery.Service) mojom.Service {
return mojom.Service{
InstanceUuid: s.InstanceUuid,
InterfaceName: s.InterfaceName,
@@ -108,28 +98,26 @@
// Scan scans for all services that match the query string passed in and calls scanHandler with updates.
// Returns the handle to this Scan.
func (d *DiscoveryService) Scan(query string, scanHandler mojom.ScanHandler_Pointer) (int32, *mojom.Error, error) {
- ctx, c := context.WithCancel(d.ctx)
+ ctx, cancel := context.WithCancel(d.ctx)
proxy := mojom.NewScanHandlerProxy(scanHandler, bindings.GetAsyncWaiter())
scanCh, err := d.s.Scan(ctx, query)
if err != nil {
- return 0, convertToErrorStruct(err), nil
+ cancel()
+ return 0, v2mError(err), nil
}
- ch := make(chan struct{})
d.mu.Lock()
id := d.nextScan
- d.pendingScans[id] = ch
+ d.activeScans[id] = cancel
d.nextScan++
d.mu.Unlock()
- d.trigger.Add(c, ch)
go func() {
for v := range scanCh {
switch value := v.(type) {
case discovery.UpdateFound:
- proxy.Found(vServiceTomService(value.Value.Service))
+ proxy.Found(v2mService(value.Value.Service))
case discovery.UpdateLost:
- proxy.Lost(vServiceTomService(value.Value.Service))
- default:
+ proxy.Lost(v2mService(value.Value.Service))
}
}
}()
@@ -139,11 +127,11 @@
// SopScan Stops the scan.
func (d *DiscoveryService) StopScan(handle int32) error {
d.mu.Lock()
- ch := d.pendingScans[handle]
- delete(d.pendingScans, handle)
+ cancel := d.activeScans[handle]
+ delete(d.activeScans, handle)
d.mu.Unlock()
- if ch != nil {
- close(ch)
+ if cancel != nil {
+ cancel()
}
return nil
}
@@ -151,12 +139,12 @@
// Stop Stops all scans and advertisements.
func (d *DiscoveryService) Stop() {
d.mu.Lock()
- for _, ch := range d.pendingScans {
- close(ch)
+ for _, cancel := range d.activeScans {
+ cancel()
}
- for _, ch := range d.pendingAdvs {
- close(ch)
+ for _, cancel := range d.activeAdvs {
+ cancel()
}
d.mu.Unlock()
}
diff --git a/go/src/vanadium/discovery/internal/discovery_test.go b/go/src/vanadium/discovery/internal/discovery_test.go
index dea5351..6c35745 100644
--- a/go/src/vanadium/discovery/internal/discovery_test.go
+++ b/go/src/vanadium/discovery/internal/discovery_test.go
@@ -1,11 +1,12 @@
package internal
+
import (
"reflect"
"testing"
+ "v.io/v23/context"
"v.io/v23/discovery"
"v.io/v23/security/access"
- "v.io/v23/context"
idiscovery "v.io/x/ref/lib/discovery"
vtest "v.io/x/ref/test"
@@ -14,21 +15,19 @@
mojom "mojom/vanadium/discovery"
)
-
type mockAdv struct {
s discovery.Service
}
type discoveryMock struct {
- trigger *idiscovery.Trigger
- id int64
+ trigger *idiscovery.Trigger
+ id int64
services map[int64]discovery.Service
// An item will be put in deleteCh when something has been deleted.
deleteCh chan struct{}
}
-
-func (d *discoveryMock) Advertise(ctx *context.T,s discovery.Service, perms access.Permissions) error {
+func (d *discoveryMock) Advertise(ctx *context.T, s discovery.Service, perms access.Permissions) error {
currId := d.id
d.services[currId] = s
d.id++
@@ -44,17 +43,10 @@
return nil, nil
}
-func compare(t *testing.T, vService discovery.Service, mService mojom.Service) {
- if !reflect.DeepEqual(vService.Addrs, mService.Addrs) {
- t.Errorf("addrs not the same: %v, %v", vService.Addrs, mService.Addrs)
- }
-
- if vService.InterfaceName != mService.InterfaceName {
- t.Errorf("interface name not the same: %v, %v", vService.InterfaceName, mService.InterfaceName)
- }
-
- if !reflect.DeepEqual(map[string]string(vService.Attrs), mService.Attrs) {
- t.Errorf("attributes not the same: %v, %v", vService.Attrs, mService.Attrs)
+func compare(t *testing.T, want discovery.Service, got mojom.Service) {
+ mwant := v2mService(want)
+ if !reflect.DeepEqual(mwant, got) {
+ t.Errorf("Got %#v want %#v", got, want)
}
}
@@ -62,18 +54,18 @@
ctx, shutdown := vtest.V23Init()
defer shutdown()
mock := &discoveryMock{
- trigger: idiscovery.NewTrigger(),
+ trigger: idiscovery.NewTrigger(),
services: map[int64]discovery.Service{},
deleteCh: make(chan struct{}),
}
s := NewDiscoveryService(ctx, mock)
- testService := mojom.Service {
+ testService := mojom.Service{
InterfaceName: "v.io/v23/discovery.T",
Attrs: map[string]string{
"key1": "value1",
"key2": "value2",
},
- Addrs: []string{ "addr1", "addr2"},
+ Addrs: []string{"addr1", "addr2"},
}
id, e1, e2 := s.Advertise(testService, nil)
@@ -88,14 +80,13 @@
compare(t, service, testService)
}
- testService2 := mojom.Service {
+ testService2 := mojom.Service{
InterfaceName: "v.io/v23/naming.T",
Attrs: map[string]string{
"key1": "value1",
"key2": "value2",
},
- Addrs: []string{ "addr1", "addr2"},
-
+ Addrs: []string{"addr1", "addr2"},
}
_, e1, e2 = s.Advertise(testService2, nil)
@@ -120,6 +111,3 @@
t.Errorf("service should have been removed")
}
}
-
-
-
diff --git a/mojom/vanadium/discovery.mojom b/mojom/vanadium/discovery.mojom
index 996c3a6..ca741e0 100644
--- a/mojom/vanadium/discovery.mojom
+++ b/mojom/vanadium/discovery.mojom
@@ -22,18 +22,32 @@
string msg;
};
-interface Discoverer {
+// Advertiser provides methods to do Vanadium Advertising.
+interface Advertiser {
+ // Advertises the given Service to all blessings that match pattern. Returns
+ // a handle to the active advertisement that can be used to stop the advertisement.
Advertise(Service s, array<string> pattern) => (int32 Handle, Error? Err);
+ // StopAdvertising Stops the advertisement associated with the given handle.
StopAdvertising(int32 h);
+};
+// Scanner provides methods to scan for Vanadium advertisements.
+interface Scanner {
+ // Scan scans for services matching the query passed nad calls ScanHandler with updates.
+ // Returns a handle to the active scanner that can be used to stop the scanning.
Scan(string query, ScanHandler scanHandler) => (int32 Handle, Error? Err);
+ // StopScan stops the scanner associated weith the given handle.
StopScan(int32 h);
};
+// ScanHandler is used to pass updates about Services that are found/lost during the
+// scan.
interface ScanHandler {
+ // Found will be called when a Service is found.
Found(Service s);
+ // Lost will be called when a service is lost.
Lost(Service s);
};
\ No newline at end of file
