func updateStatus(ctx *context.T, args []string, status lock.LockStatus) error {
if numargs := len(args); numargs != 1 {
return fmt.Errorf("requires exactly one arguments <lock>, provided %d", numargs)
}
lockName := args[0]
ctx, stop, err := withLocalNamespace(ctx, "", lockUserNhName(ctx))
if err != nil {
return err
}
defer stop()
ctx, cancel := context.WithTimeout(ctx, time.Minute)
defer cancel()
if status == lock.Locked {
err = lock.LockClient(lockObjName(lockName)).Lock(ctx)
} else {
err = lock.LockClient(lockObjName(lockName)).Unlock(ctx)
}
if err != nil {
return err
}
fmt.Printf("Updated lock %v to status: %v\n", lockName, status)
return nil
}
func runClaim(ctx *context.T, env *cmdline.Env, args []string) error {
if numargs := len(args); numargs != 2 {
return fmt.Errorf("requires exactly two arguments <lock>, <name>, provided %d", numargs)
}
lockName, name := args[0], args[1]
ctx, stop, err := withLocalNamespace(ctx, "", lockUserNhName(ctx))
if err != nil {
return err
}
defer stop()
ctx, cancel := context.WithTimeout(ctx, time.Minute)
defer cancel()
// TODO(ataly): We should not skip server endpoint authorization while
// claiming locks but instead fetch the blessing root of the lock manufacturer
// from an authoritative source and then appropriately authenticate the server.
b, err := lock.UnclaimedLockClient(lockObjName(lockName)).Claim(
ctx,
name,
options.ServerAuthorizer{security.AllowEveryone()})
if err != nil {
return err
}
p := v23.GetPrincipal(ctx)
if err := security.AddToRoots(p, b); err != nil {
return fmt.Errorf("failed to add (key) blessing (%v) to roots: %v", b, err)
}
if _, err := p.BlessingStore().Set(b, security.BlessingPattern(name)); err != nil {
return fmt.Errorf("failed to set (key) blessing (%v) for peer %v: %v", b, name, err)
}
fmt.Printf("Claimed lock: %v as %v and received key: %v\n", lockName, name, b)
return nil
}
// sendOneInvite sends invitations to all the addresses in addrs and returns the one that accepted it.
// All addrs are assumed to be equivalent and thus at most one Invite RPC will succeed.
//
// TODO: This is aiming to replicate what the RPC stack does for all the
// addresses a single name resolved to. Should all these addresses discovered
// somehow be encapsulated in a single object name?
func sendOneInvite(ctx *context.T, addrs []string) string {
// Give at most 1 second for these connections to be made, if they
// can't be made then consider the peer bad and ignore it.
// TODO: Should these RPCs also use the "connection timeout" that might be implemented
// as per proposal: https://docs.google.com/a/google.com/document/d/1prtxGhSR5TaL0lc_iDRC0Q6H1Drbg2T0x7MWVb_ZCSM/edit?usp=sharing
ctx, cancel := context.WithTimeout(ctx, maxInvitationWaitTime)
defer cancel()
ch := make(chan string)
for _, addr := range addrs {
go func(addr string) {
err := spec.ScreenClient(addr).Invite(ctx, options.ServerAuthorizer{security.AllowEveryone()})
ctx.Infof("Invitation to %v sent, error: %v", addr, err)
if err == nil {
ch <- addr
return
}
ch <- ""
}(addr)
}
for i := range addrs {
if ret := <-ch; len(ret) > 0 {
// Drain the rest and return
go func() {
i++
for i < len(addrs) {
<-ch
}
}()
return ret
}
}
return ""
}
// Return array of known players.
func (nm *V23Manager) playerNumbers() (list []int) {
list = []int{}
rCtx, cancel := context.WithTimeout(nm.ctx, time.Minute)
defer cancel()
if nm.chatty {
log.Printf("Recovering namespace.")
}
ns := v23.GetNamespace(rCtx)
if nm.chatty {
log.Printf("namespace == %T %v", ns, ns)
}
pattern := nm.rootName + "*"
if nm.chatty {
log.Printf("Calling glob with %T=%v, pattern=%v\n",
rCtx, rCtx, pattern)
}
c, err := ns.Glob(rCtx, pattern)
if err != nil {
log.Printf("ns.Glob(%v) failed: %v", pattern, err)
return
}
if nm.chatty {
log.Printf("Awaiting response from Glob request.")
}
for res := range c {
if nm.chatty {
log.Printf("Got a result: %v\n", res)
}
switch v := res.(type) {
case *naming.GlobReplyEntry:
name := v.Value.Name
if nm.chatty {
log.Printf("Raw name is: %v\n", name)
}
if name != "" {
putativeNumber := name[len(nm.rootName):]
n, err := strconv.ParseInt(putativeNumber, 10, 32)
if err != nil {
log.Println(err)
} else {
list = append(list, int(n))
}
if nm.chatty {
log.Println("Found player: ", v.Value.Name)
}
}
default:
}
}
if nm.chatty {
log.Printf("Finished processing glob response.")
}
return
}
//export swift_io_v_v23_context_VContext_nativeWithTimeout
func swift_io_v_v23_context_VContext_nativeWithTimeout(ctxHandle C.GoContextHandle, nsTimeout C.double, errOut *C.SwiftVError) C.GoCancelableContextHandle {
ctx := GoContext(uint64(ctxHandle))
timeout := sutil.GoDuration(float64(nsTimeout))
ctx, cancelFunc := context.WithTimeout(ctx, timeout)
swiftCtx, err := SwiftCancelableContext(ctx, cancelFunc)
if err != nil {
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
return C.GoCancelableContextHandle(0)
}
return C.GoCancelableContextHandle(swiftCtx)
}
//export Java_io_v_v23_context_VContext_nativeWithTimeout
func Java_io_v_v23_context_VContext_nativeWithTimeout(jenv *C.JNIEnv, jVContext C.jobject, goRef C.jlong, jTimeout C.jobject) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
timeout, err := jutil.GoDuration(env, jutil.Object(uintptr(unsafe.Pointer(jTimeout))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
ctx, cancelFunc := context.WithTimeout((*context.T)(jutil.GoRefValue(jutil.Ref(goRef))), timeout)
jCtx, err := JavaContext(env, ctx, cancelFunc)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jCtx))
}
func channel2rpc(ctx *context.T, src <-chan *spec.Triangle, dst string, errch chan<- error, myScreen chan<- *spec.Triangle) {
for t := range src {
// This is an "interactive" game, if an RPC doesn't succeed in say
ctxTimeout, cancel := context.WithTimeout(ctx, maxTriangleGiveTime)
if err := spec.ScreenClient(dst).Give(ctxTimeout, *t, options.ServerAuthorizer{security.AllowEveryone()}); err != nil {
cancel()
returnTriangle(t, myScreen)
ctx.Infof("%q.Give failed: %v, aborting connection with remote screen", dst, err)
errch <- err
break
}
cancel()
}
for t := range src {
returnTriangle(t, myScreen)
}
ctx.VI(1).Infof("Exiting goroutine with connection to %q", dst)
}
func runStatus(ctx *context.T, env *cmdline.Env, args []string) error {
if numargs := len(args); numargs != 1 {
return fmt.Errorf("requires exactly one arguments <lock>, provided %d", numargs)
}
lockName := args[0]
ctx, stop, err := withLocalNamespace(ctx, "", lockUserNhName(ctx))
if err != nil {
return err
}
defer stop()
ctx, cancel := context.WithTimeout(ctx, time.Minute)
defer cancel()
status, err := lock.LockClient(lockObjName(lockName)).Status(ctx)
if err != nil {
return err
}
fmt.Printf("lock %v is: %v\n", lockName, status)
return nil
}
