| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package main |
| |
| import ( |
| "fmt" |
| "strings" |
| |
| "v.io/v23" |
| "v.io/v23/context" |
| "v.io/v23/glob" |
| "v.io/v23/naming" |
| "v.io/v23/rpc" |
| "v.io/v23/security" |
| |
| "v.io/x/lib/cmdline" |
| "v.io/x/lib/vlog" |
| "v.io/x/ref/lib/signals" |
| "v.io/x/ref/lib/v23cmd" |
| "v.io/x/ref/lib/xrpc" |
| _ "v.io/x/ref/runtime/factories/roaming" |
| "v.io/x/ref/services/mounttable/mounttablelib" |
| "v.io/x/ref/test/discovery/a" |
| "v.io/x/ref/test/discovery/b" |
| ) |
| |
| var ( |
| mtPort int |
| nhName string |
| ) |
| |
| func init() { |
| cmdRun.Flags.IntVar(&mtPort, "mtport", 9000, "port number of mounttable to run") |
| cmdRun.Flags.StringVar(&nhName, "nhname", "", "neighborhood mt name") |
| } |
| |
| var cmdRun = &cmdline.Command{ |
| Runner: v23cmd.RunnerFunc(runServer), |
| Name: "run", |
| Short: "Run a server for testing discovery", |
| } |
| |
| func runServer(ctx *context.T, env *cmdline.Env, args []string) error { |
| mtName, stopMT, err := startMounttable(ctx) |
| if err != nil { |
| return err |
| } |
| defer stopMT() |
| ctx, _, err = v23.WithNewNamespace(ctx, mtName) |
| if err != nil { |
| return err |
| } |
| server, err := xrpc.NewDispatchingServer(ctx, "test2", disp2{}) |
| if err != nil { |
| ctx.Fatalf("NewServer failed: %v", err) |
| } |
| ctx.Infof("Listening on %s", server.Status().Endpoints[0].Name()) |
| <-signals.ShutdownOnSignals(ctx) |
| return nil |
| } |
| |
| func startMounttable(ctx *context.T) (string, func(), error) { |
| listenSpec := rpc.ListenSpec{Addrs: rpc.ListenAddrs{{"wsh", fmt.Sprintf(":%d", mtPort)}}} |
| mtName, stopMT, err := mounttablelib.StartServers(ctx, listenSpec, "", nhName, "", "", "mounttable") |
| if err != nil { |
| vlog.Errorf("mounttablelib.StartServers failed: %v", err) |
| return "", nil, err |
| } |
| vlog.Infof("Started local mounttable at: %v", mtName) |
| return mtName, stopMT, nil |
| } |
| |
| var services2 map[string]rpc.Invoker |
| |
| func init() { |
| services2 = make(map[string]rpc.Invoker) |
| services2["a"] = rpc.ReflectInvokerOrDie(a.AServiceServer(&impl{})) |
| services2["b"] = rpc.ReflectInvokerOrDie(b.AnotherServiceServer(&impl{})) |
| services2["c"] = rpc.ReflectInvokerOrDie(b.AnotherServiceServer(&impl{})) |
| services2["d/e"] = rpc.ReflectInvokerOrDie(a.AServiceServer(&impl{})) |
| } |
| |
| type disp2 struct{} |
| |
| func (_ disp2) Lookup(_ *context.T, suffix string) (interface{}, security.Authorizer, error) { |
| suffix = strings.TrimLeft(suffix, "/") |
| if suffix == "" { |
| return rpc.ReflectInvokerOrDie(&root{}), security.AllowEveryone(), nil |
| } |
| invoker, ok := services2[suffix] |
| if ok { |
| return invoker, security.AllowEveryone(), nil |
| } |
| return nil, nil, nil |
| } |
| |
| type root struct{} |
| |
| func (r *root) Glob__(ctx *context.T, call rpc.ServerCall, pattern string) (<-chan naming.GlobReply, error) { |
| return r.GlobWithPredicate__(ctx, call, pattern, "") |
| } |
| |
| func (r *root) GlobWithPredicate__(ctx *context.T, call rpc.ServerCall, pattern, predicate string) (<-chan naming.GlobReply, error) { |
| p, err := glob.ParsePredicate(predicate) |
| if err != nil { |
| return nil, err |
| } |
| |
| ch := make(chan naming.GlobReply) |
| go func() { |
| defer close(ch) |
| |
| for suffix, invoker := range services2 { |
| sigs, err := invoker.Signature(ctx, nil) |
| if err != nil { |
| ch <- naming.GlobReplyError{naming.GlobError{Error: err}} |
| continue |
| } |
| |
| interfaces := make([]string, len(sigs)) |
| for i, sig := range sigs { |
| interfaces[i] = sig.PkgPath |
| } |
| if p == nil || p.Match(naming.Properties{naming.PropInterface: interfaces}) { |
| ch <- naming.GlobReplyEntry{naming.MountEntry{Name: suffix, IsLeaf: true}} |
| } |
| } |
| }() |
| return ch, nil |
| } |
| |
| type impl struct{} |
| |
| func (i *impl) AMethod(_ *context.T, _ rpc.ServerCall) error { return nil } |
| func (i *impl) AnotherMethod(_ *context.T, _ rpc.ServerCall) error { return nil } |
| |
| func main() { |
| cmdline.HideGlobalFlagsExcept() |
| cmdline.Main(cmdRun) |
| } |