ref: Change context mutators from SetFoo to WithFoo.
The motivation for this change is consistency, so our API becomes
easier to use.
Before this CL we were using the WithFoo style in the context
package, but the SetFoo style elsewhere, sometimes with an extra
"Context" thrown in for kicks. After this CL we use WithFoo (and
GetFoo) everywhere.
Change-Id: Idc6959e4ea76ca6bd36501f4002145ffa8835c04
MultiPart: 2/4
diff --git a/profiles/internal/rpc/cancel_test.go b/profiles/internal/rpc/cancel_test.go
index 60b0033..c14d120 100644
--- a/profiles/internal/rpc/cancel_test.go
+++ b/profiles/internal/rpc/cancel_test.go
@@ -94,8 +94,8 @@
sm = manager.InternalNew(naming.FixedRoutingID(0x555555555))
ns = tnaming.NewSimpleNamespace()
pclient, pserver = newClientServerPrincipals()
- serverCtx, _ = v23.SetPrincipal(ctx, pserver)
- clientCtx, _ = v23.SetPrincipal(ctx, pclient)
+ serverCtx, _ = v23.WithPrincipal(ctx, pserver)
+ clientCtx, _ = v23.WithPrincipal(ctx, pclient)
)
client, err := InternalNewClient(sm, ns)
if err != nil {
diff --git a/profiles/internal/rpc/client.go b/profiles/internal/rpc/client.go
index 8de92b7..8525a47 100644
--- a/profiles/internal/rpc/client.go
+++ b/profiles/internal/rpc/client.go
@@ -308,7 +308,7 @@
if !ctx.Initialized() {
return nil, verror.ExplicitNew(verror.ErrBadArg, i18n.LangID("en-us"), "<rpc.Client>", "StartCall", "context not initialized")
}
- ctx, span := vtrace.SetNewSpan(ctx, fmt.Sprintf("<rpc.Client>%q.%s", name, method))
+ ctx, span := vtrace.WithNewSpan(ctx, fmt.Sprintf("<rpc.Client>%q.%s", name, method))
if err := canCreateServerAuthorizer(ctx, opts); err != nil {
return nil, verror.New(verror.ErrBadArg, ctx, err)
}
@@ -362,7 +362,7 @@
func (c *client) tryCreateFlow(ctx *context.T, principal security.Principal, index int, name, server, method string, auth security.Authorizer, ch chan<- *serverStatus, vcOpts []stream.VCOpt) {
status := &serverStatus{index: index, server: server}
var span vtrace.Span
- ctx, span = vtrace.SetNewSpan(ctx, "<client>tryCreateFlow")
+ ctx, span = vtrace.WithNewSpan(ctx, "<client>tryCreateFlow")
span.Annotatef("address:%v", server)
defer func() {
ch <- status
@@ -466,7 +466,7 @@
// initialization. Currently, the agent, which uses SecurityNone, is the only caller
// during runtime initialization. We would like to set the principal in the context
// to nil if we are running in SecurityNone, but this always results in a panic since
- // the agent client would trigger the call v23.SetPrincipal during runtime
+ // the agent client would trigger the call v23.WithPrincipal during runtime
// initialization. So, we gate the call to v23.GetPrincipal instead since the agent
// client will have callEncrypted == false.
// Potential solutions to this are:
diff --git a/profiles/internal/rpc/debug_test.go b/profiles/internal/rpc/debug_test.go
index b4081fe..cdae902 100644
--- a/profiles/internal/rpc/debug_test.go
+++ b/profiles/internal/rpc/debug_test.go
@@ -53,7 +53,7 @@
if err := server.Serve("", &testObject{}, nil); err != nil {
t.Fatalf("server.Serve failed: %v", err)
}
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
client, err := InternalNewClient(sm, ns)
if err != nil {
t.Fatalf("InternalNewClient failed: %v", err)
diff --git a/profiles/internal/rpc/discharges.go b/profiles/internal/rpc/discharges.go
index b6c7bf9..9417172 100644
--- a/profiles/internal/rpc/discharges.go
+++ b/profiles/internal/rpc/discharges.go
@@ -91,7 +91,7 @@
}
if ctx != nil {
var span vtrace.Span
- ctx, span = vtrace.SetNewSpan(ctx, "Fetching Discharges")
+ ctx, span = vtrace.WithNewSpan(ctx, "Fetching Discharges")
defer span.Finish()
}
d.fetchDischarges(ctx, caveats, filteredImpetuses, discharges)
diff --git a/profiles/internal/rpc/full_test.go b/profiles/internal/rpc/full_test.go
index 838c43b..7729e21 100644
--- a/profiles/internal/rpc/full_test.go
+++ b/profiles/internal/rpc/full_test.go
@@ -234,7 +234,7 @@
func startServerWS(t *testing.T, ctx *context.T, principal security.Principal, sm stream.Manager, ns namespace.T, name string, disp rpc.Dispatcher, shouldUseWebsocket websocketMode, opts ...rpc.ServerOpt) (naming.Endpoint, rpc.Server) {
vlog.VI(1).Info("InternalNewServer")
- ctx, _ = v23.SetPrincipal(ctx, principal)
+ ctx, _ = v23.WithPrincipal(ctx, principal)
server, err := testInternalNewServer(ctx, sm, ns, principal, opts...)
if err != nil {
t.Errorf("InternalNewServer failed: %v", err)
@@ -534,7 +534,7 @@
// (that are blessed by pprovider).
pclient.BlessingStore().Set(bless(pprovider, pclient, "client"), "root")
- clientCtx, _ := v23.SetPrincipal(ctx, pclient)
+ clientCtx, _ := v23.WithPrincipal(ctx, pclient)
client, err := InternalNewClient(mgr, ns)
if err != nil {
t.Fatal(err)
@@ -639,7 +639,7 @@
t.Fatal(err)
}
defer client.Close()
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
if _, err := client.StartCall(ctx, "mountpoint/server", "Closure", nil); verror.ErrorID(err) != verror.ErrNotTrusted.ID {
t.Errorf("Got error %v (errorid=%v), want errorid=%v", err, verror.ErrorID(err), verror.ErrNotTrusted.ID)
}
@@ -716,7 +716,7 @@
b = createBundleWS(t, ctx, pserver, &testServer{}, shouldUseWebsocket)
)
defer b.cleanup(t, ctx)
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
for _, test := range tests {
vlog.VI(1).Infof("%s client.StartCall", name(test))
vname := test.name
@@ -783,7 +783,7 @@
b = createBundle(t, ctx, pserver, &testServer{})
)
defer b.cleanup(t, ctx)
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
call, err := b.client.StartCall(ctx, "mountpoint/server/suffix", "Echo", v{"foo"})
if err != nil {
t.Fatalf(`client.StartCall got error "%v"`, err)
@@ -826,7 +826,7 @@
defer shutdown()
defer b.cleanup(t, ctx)
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
tests := []struct {
granter rpc.Granter
startErrID, finishErrID verror.IDAction
@@ -971,7 +971,7 @@
for _, test := range tests {
pclient := setClientBlessings(test.Requirements)
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
client, err := InternalNewClient(sm, ns)
if err != nil {
t.Fatalf("InternalNewClient(%+v) failed: %v", test.Requirements, err)
@@ -1132,7 +1132,7 @@
defer client.Close()
pclient.BlessingStore().Set(test.blessings, "server")
- ctx, _ := v23.SetPrincipal(ctx, pclient)
+ ctx, _ := v23.WithPrincipal(ctx, pclient)
err = client.Call(ctx, test.name, test.method, test.args, makeResultPtrs(test.results))
if err != nil && test.authorized {
t.Errorf(`%s client.Call got error: "%v", wanted the RPC to succeed`, name, err)
@@ -1207,7 +1207,7 @@
b := createBundle(t, ctx, pserver, &testServer{})
defer b.cleanup(t, ctx)
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
tests := []struct {
blessings security.Blessings
errID verror.IDAction
@@ -1268,7 +1268,7 @@
}
defer client.Close()
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
var gotServer, gotClient string
if err := client.Call(ctx, "mountpoint/server/suffix", "EchoBlessings", nil, []interface{}{&gotServer, &gotClient}); err != nil {
t.Fatalf("Finish failed: %v", err)
@@ -1301,7 +1301,7 @@
if b.client, err = InternalNewClient(b.sm, b.ns); err != nil {
t.Fatalf("InternalNewClient failed: %v", err)
}
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
call := func() error {
var got string
if err := b.client.Call(ctx, "mountpoint/server/aclAuth", "Echo", []interface{}{"batman"}, []interface{}{&got}); err != nil {
@@ -1380,7 +1380,7 @@
)
defer b.cleanup(t, ctx)
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
ctx, cancel := context.WithCancel(ctx)
_, err := b.client.StartCall(ctx, "mountpoint/server/suffix", "CancelStreamReader", []interface{}{})
if err != nil {
@@ -1401,7 +1401,7 @@
)
defer b.cleanup(t, ctx)
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
ctx, cancel := context.WithCancel(ctx)
call, err := b.client.StartCall(ctx, "mountpoint/server/suffix", "CancelStreamIgnorer", []interface{}{})
if err != nil {
@@ -1444,7 +1444,7 @@
)
defer b.cleanup(t, ctx)
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
call, err := b.client.StartCall(ctx, "mountpoint/server/suffix", "RecvInGoroutine", []interface{}{})
if err != nil {
t.Fatalf("StartCall failed: %v", err)
@@ -1490,7 +1490,7 @@
publisher.AddServer("/@2@tcp@localhost:10000@@1000000@2000000@@")
publisher.AddServer("/@2@tcp@localhost:10001@@2000000@3000000@@")
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
_, err := b.client.StartCall(ctx, "incompatible/suffix", "Echo", []interface{}{"foo"}, options.NoRetry{})
if verror.ErrorID(err) != verror.ErrNoServers.ID {
t.Errorf("Expected error %s, found: %v", verror.ErrNoServers, err)
@@ -1647,7 +1647,7 @@
}
// A call should fail if the principal in the ctx is nil and SecurityNone is not specified.
- ctx, err = v23.SetPrincipal(ctx, nil)
+ ctx, err = v23.WithPrincipal(ctx, nil)
if err != nil {
t.Fatalf("failed to set principal: %v", err)
}
@@ -1709,7 +1709,7 @@
return nil, err
}
defer client.Close()
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
call, err := client.StartCall(ctx, server, "Closure", nil)
if err != nil {
return nil, err
@@ -1777,7 +1777,7 @@
if noDischarges {
opts = append(opts, NoDischarges{})
}
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
if _, err = client.StartCall(ctx, "mountpoint/testServer", "Closure", nil, opts...); err != nil {
t.Fatalf("failed to StartCall: %v", err)
}
@@ -1839,7 +1839,7 @@
if err != nil {
t.Error(err)
}
- ctx, _ = v23.SetPrincipal(ctx, pdischargeClient)
+ ctx, _ = v23.WithPrincipal(ctx, pdischargeClient)
dc.PrepareDischarges(ctx, []security.Caveat{tpcav2}, security.DischargeImpetus{})
// Ensure that discharger1 was not called and discharger2 was called.
@@ -1871,7 +1871,7 @@
defer serverSM.Shutdown()
rid := serverSM.RoutingID()
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
newClient := func() rpc.Client {
rid, err := naming.NewRoutingID()
@@ -1963,7 +1963,7 @@
defer smc.Shutdown()
defer client.Close()
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
// The call should succeed when the server presents the same public as the opt...
if _, err = client.StartCall(ctx, mountName, "Closure", nil, options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{pserver.PublicKey()}); err != nil {
t.Errorf("Expected call to succeed but got %v", err)
@@ -2027,7 +2027,7 @@
t.Fatalf("failed to create client: %v", err)
}
defer client.Close()
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
dc := InternalNewDischargeClient(ctx, client, 0)
// Fetch discharges for tpcav.
diff --git a/profiles/internal/rpc/server.go b/profiles/internal/rpc/server.go
index 9898a34..91b3a1a 100644
--- a/profiles/internal/rpc/server.go
+++ b/profiles/internal/rpc/server.go
@@ -175,7 +175,7 @@
principal security.Principal,
opts ...rpc.ServerOpt) (rpc.Server, error) {
ctx, cancel := context.WithRootCancel(ctx)
- ctx, _ = vtrace.SetNewSpan(ctx, "NewServer")
+ ctx, _ = vtrace.WithNewSpan(ctx, "NewServer")
statsPrefix := naming.Join("rpc", "server", "routing-id", streamMgr.RoutingID().String())
s := &server{
ctx: ctx,
@@ -1105,7 +1105,7 @@
if err != nil {
// We don't know what the rpc call was supposed to be, but we'll create
// a placeholder span so we can capture annotations.
- fs.ctx, _ = vtrace.SetNewSpan(fs.ctx, fmt.Sprintf("\"%s\".UNKNOWN", fs.suffix))
+ fs.ctx, _ = vtrace.WithNewSpan(fs.ctx, fmt.Sprintf("\"%s\".UNKNOWN", fs.suffix))
return nil, err
}
fs.method = req.Method
@@ -1115,7 +1115,7 @@
// on the server even if they will not be allowed to collect the
// results later. This might be considered a DOS vector.
spanName := fmt.Sprintf("\"%s\".%s", fs.suffix, fs.method)
- fs.ctx, _ = vtrace.SetContinuedTrace(fs.ctx, spanName, req.TraceRequest)
+ fs.ctx, _ = vtrace.WithContinuedTrace(fs.ctx, spanName, req.TraceRequest)
var cancel context.CancelFunc
if !req.Deadline.IsZero() {
diff --git a/profiles/internal/rpc/server_authorizer_test.go b/profiles/internal/rpc/server_authorizer_test.go
index 36e4c94..f9625fc 100644
--- a/profiles/internal/rpc/server_authorizer_test.go
+++ b/profiles/internal/rpc/server_authorizer_test.go
@@ -38,7 +38,7 @@
}
)
defer shutdown()
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
// Make client recognize ali, bob and otherAli blessings
for _, b := range []security.Blessings{ali, bob, otherAli} {
if err := pclient.AddToRoots(b); err != nil {
diff --git a/profiles/internal/rpc/server_test.go b/profiles/internal/rpc/server_test.go
index 095e902..4e4dbe5 100644
--- a/profiles/internal/rpc/server_test.go
+++ b/profiles/internal/rpc/server_test.go
@@ -76,7 +76,7 @@
if err != nil {
t.Fatalf("InternalNewClient failed: %v", err)
}
- ctx, _ = v23.SetPrincipal(ctx, pclient)
+ ctx, _ = v23.WithPrincipal(ctx, pclient)
ctx, _ = context.WithDeadline(ctx, time.Now().Add(10*time.Second))
var result string
if err := client.Call(ctx, "servername", "SomeMethod", nil, []interface{}{&result}); err == nil {
@@ -169,7 +169,7 @@
progress := make(chan error)
client, err := InternalNewClient(sm, ns)
- ctx, _ = v23.SetPrincipal(ctx, principal)
+ ctx, _ = v23.WithPrincipal(ctx, principal)
makeCall := func(ctx *context.T) {
call, err := client.StartCall(ctx, "test", "Hang", nil)
progress <- err
diff --git a/profiles/internal/rpc/stream/vif/vif.go b/profiles/internal/rpc/stream/vif/vif.go
index e59a153..eb4776c 100644
--- a/profiles/internal/rpc/stream/vif/vif.go
+++ b/profiles/internal/rpc/stream/vif/vif.go
@@ -169,7 +169,7 @@
ctx := getDialContext(opts)
if ctx != nil {
var span vtrace.Span
- ctx, span = vtrace.SetNewSpan(ctx, "InternalNewDialedVIF")
+ ctx, span = vtrace.WithNewSpan(ctx, "InternalNewDialedVIF")
span.Annotatef("(%v, %v)", conn.RemoteAddr().Network(), conn.RemoteAddr())
defer span.Finish()
}
diff --git a/profiles/internal/rpc/test/client_test.go b/profiles/internal/rpc/test/client_test.go
index 62a094b..caf87ab 100644
--- a/profiles/internal/rpc/test/client_test.go
+++ b/profiles/internal/rpc/test/client_test.go
@@ -331,7 +331,7 @@
// The following tests will fail with NoServers, but because there are
// no protocols that the client and servers (mount table, and "name") share.
- nctx, nclient, err := v23.SetNewClient(ctx, irpc.PreferredProtocols([]string{"wsh"}))
+ nctx, nclient, err := v23.WithNewClient(ctx, irpc.PreferredProtocols([]string{"wsh"}))
addr := naming.FormatEndpoint("nope", "127.0.0.1:1081")
if err := ns.Mount(ctx, "name", addr, time.Minute); err != nil {
@@ -494,7 +494,7 @@
// Create a context with a new principal that doesn't match the server,
// so that the client will not trust the server.
- ctx1, err := v23.SetPrincipal(ctx, testutil.NewPrincipal("test-blessing"))
+ ctx1, err := v23.WithPrincipal(ctx, testutil.NewPrincipal("test-blessing"))
if err != nil {
t.Fatal(err)
}
@@ -595,7 +595,7 @@
name, fn := initServer(t, ctx)
defer fn()
- ctx1, err := v23.SetPrincipal(ctx, testutil.NewPrincipal("test-blessing"))
+ ctx1, err := v23.WithPrincipal(ctx, testutil.NewPrincipal("test-blessing"))
// Client must recognize the server, otherwise it won't even send the request.
v23.GetPrincipal(ctx1).AddToRoots(v23.GetPrincipal(ctx).BlessingStore().Default())
if err != nil {
diff --git a/profiles/internal/rpc/test/glob_test.go b/profiles/internal/rpc/test/glob_test.go
index 5b73a0f..9c2ca36 100644
--- a/profiles/internal/rpc/test/glob_test.go
+++ b/profiles/internal/rpc/test/glob_test.go
@@ -229,7 +229,7 @@
}
// Ensure that we're getting the english error message.
- ctx = i18n.ContextWithLangID(ctx, i18n.LangID("en-US"))
+ ctx = i18n.WithLangID(ctx, i18n.LangID("en-US"))
for _, tc := range testcases {
name := naming.JoinAddressName(ep, tc.name)
diff --git a/profiles/internal/rpc/test/proxy_test.go b/profiles/internal/rpc/test/proxy_test.go
index 66719d2..ab8c7e9 100644
--- a/profiles/internal/rpc/test/proxy_test.go
+++ b/profiles/internal/rpc/test/proxy_test.go
@@ -43,7 +43,7 @@
if ctx, err = ivtrace.Init(ctx, flags.VtraceFlags{}); err != nil {
panic(err)
}
- ctx, _ = vtrace.SetNewTrace(ctx)
+ ctx, _ = vtrace.WithNewTrace(ctx)
return ctx, shutdown
}
@@ -183,7 +183,7 @@
t.Fatal(err)
}
defer client.Close()
- serverCtx, _ := v23.SetPrincipal(ctx, pserver)
+ serverCtx, _ := v23.WithPrincipal(ctx, pserver)
server, err := irpc.InternalNewServer(serverCtx, smserver, ns, nil, pserver)
if err != nil {
t.Fatal(err)
@@ -200,7 +200,7 @@
name := "mountpoint/server/suffix"
makeCall := func(opts ...rpc.CallOpt) (string, error) {
- clientCtx, _ := v23.SetPrincipal(ctx, pclient)
+ clientCtx, _ := v23.WithPrincipal(ctx, pclient)
clientCtx, _ = context.WithDeadline(clientCtx, time.Now().Add(5*time.Second))
call, err := client.StartCall(clientCtx, name, "Echo", []interface{}{"batman"}, opts...)
if err != nil {
diff --git a/profiles/internal/rpc/testutil_test.go b/profiles/internal/rpc/testutil_test.go
index 1e51fa4..921335e 100644
--- a/profiles/internal/rpc/testutil_test.go
+++ b/profiles/internal/rpc/testutil_test.go
@@ -84,7 +84,7 @@
if err != nil {
panic(err)
}
- ctx, _ = vtrace.SetNewTrace(ctx)
+ ctx, _ = vtrace.WithNewTrace(ctx)
return ctx, shutdown
}
