func TestPassMessagePipe(t *testing.T) {
r, p := bindings.CreateMessagePipeForMojoInterface()
r1, p1 := r, p
handle := r1.PassMessagePipe()
defer handle.Close()
p1.Close()
rhandle, phandle := r.PassMessagePipe(), p.PassMessagePipe()
if rhandle.IsValid() || phandle.IsValid() {
t.Fatal("message pipes should be invalid after PassMessagePipe() or Close()")
}
rhandle.Close()
phandle.Close()
}
// Invoke calls the mojom service based on the suffix and converts the mojom
// results (a struct) to Vanadium results (a slice of *vom.RawBytes).
// Note: The argptrs from Prepare are reused here. The vom bytes should have
// been decoded into these argptrs, so there are actual values inside now.
func (fs fakeService) Invoke(ctx *context.T, call rpc.StreamServerCall, method string, argptrs []interface{}) (results []interface{}, _ error) {
// fs.suffix consists of the mojo url and the application/interface name.
// The last part should be the name; everything else is the url.
parts := strings.Split(fs.suffix, "/")
mojourl := strings.Join(parts[:len(parts)-1], "/") // e.g., mojo:go_remote_echo_server. May be defined in a BUILD.gn file.
mojoname := parts[len(parts)-1] // e.g., mojo::examples::RemoteEcho. Defined from the interface + module.
// Create the generic message pipe. r is a bindings.InterfaceRequest, and
// p is a bindings.InterfacePointer.
r, p := bindings.CreateMessagePipeForMojoInterface()
v := v23ServiceRequest{
request: r,
name: mojoname,
} // v is an application.ServiceRequest with mojoname
// Connect to the mojourl.
fs.appctx.ConnectToApplication(mojourl).ConnectToService(&v)
// Then assign a new router the FakeService.
// This will never conflict because each FakeService is only invoked once.
fs.router = bindings.NewRouter(p.PassMessagePipe(), bindings.GetAsyncWaiter())
defer fs.Close_Proxy()
ctx.Infof("Fake Service Invoke (Remote Signature: %q -- %q)", mojourl, mojoname)
// Vanadium relies on type information, so we will retrieve that first.
mojomInterface, desc, err := fs.callRemoteSignature(mojourl, mojoname)
if err != nil {
return nil, err
}
ctx.Infof("Fake Service Invoke Signature %v", mojomInterface)
ctx.Infof("Fake Service Invoke (Remote Method: %v)", method)
// With the type information, we can make the method call to the remote interface.
methodResults, err := fs.callRemoteMethod(ctx, method, mojomInterface, desc, argptrs)
if err != nil {
ctx.Errorf("Method called failed: %v", err)
return nil, err
}
ctx.Infof("Fake Service Invoke Results %v", methodResults)
// Convert methodResult to results.
results = make([]interface{}, len(methodResults))
for i := range methodResults {
results[i] = &methodResults[i]
}
return results, nil
}
