Merge "ref/runtime/internal/stream/manager: Prevent lingering goroutine."
diff --git a/cmd/mounttable/impl_test.go b/cmd/mounttable/impl_test.go
index 09875f3..fad262e 100644
--- a/cmd/mounttable/impl_test.go
+++ b/cmd/mounttable/impl_test.go
@@ -36,7 +36,9 @@
}
func deadline(minutes int) vdltime.Deadline {
- return vdltime.Deadline{now.Add(time.Minute * time.Duration(minutes))}
+ return vdltime.Deadline{
+ Time: now.Add(time.Minute * time.Duration(minutes)),
+ }
}
type server struct {
@@ -46,8 +48,22 @@
func (s *server) Glob__(ctx *context.T, call rpc.GlobServerCall, g *glob.Glob) error {
ctx.VI(2).Infof("Glob() was called. suffix=%v pattern=%q", s.suffix, g.String())
sender := call.SendStream()
- sender.Send(naming.GlobReplyEntry{naming.MountEntry{"name1", []naming.MountedServer{{"server1", deadline(1)}}, false, false}})
- sender.Send(naming.GlobReplyEntry{naming.MountEntry{"name2", []naming.MountedServer{{"server2", deadline(2)}, {"server3", deadline(3)}}, false, false}})
+ sender.Send(naming.GlobReplyEntry{
+ Value: naming.MountEntry{
+ Name: "name1",
+ Servers: []naming.MountedServer{{"server1", deadline(1)}},
+ ServesMountTable: false,
+ IsLeaf: false,
+ },
+ })
+ sender.Send(naming.GlobReplyEntry{
+ Value: naming.MountEntry{
+ Name: "name2",
+ Servers: []naming.MountedServer{{"server2", deadline(2)}, {"server3", deadline(3)}},
+ ServesMountTable: false,
+ IsLeaf: false,
+ },
+ })
return nil
}
diff --git a/cmd/principal/bless.go b/cmd/principal/bless.go
index ca6c46c..2c24366 100644
--- a/cmd/principal/bless.go
+++ b/cmd/principal/bless.go
@@ -36,7 +36,9 @@
// Authorize the server by its public key (obtained from macaroonChan).
// Must skip authorization during name resolution because the identity
// service is not a trusted root yet.
- blessings, err := identity.MacaroonBlesserClient(service).Bless(ctx, macaroon, options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{serviceKey})
+ blessings, err := identity.MacaroonBlesserClient(service).Bless(ctx, macaroon, options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{
+ PublicKey: serviceKey,
+ })
if err != nil {
return security.Blessings{}, fmt.Errorf("failed to get blessing from %q: %v", service, err)
}
diff --git a/cmd/vdl/arith_test.go b/cmd/vdl/arith_test.go
index d0294ae..8cb78b7 100644
--- a/cmd/vdl/arith_test.go
+++ b/cmd/vdl/arith_test.go
@@ -309,14 +309,14 @@
if q != 2 || r != 1 {
t.Errorf("DivMod: expected (2,1) got (%d,%d)", q, r)
}
- diff, err := ar.Sub(ctx, base.Args{7, 8})
+ diff, err := ar.Sub(ctx, base.Args{A: 7, B: 8})
if err != nil {
t.Errorf("Sub: got %q but expected no error", err)
}
if diff != -1 {
t.Errorf("Sub: got %d, expected -1", diff)
}
- prod, err := ar.Mul(ctx, base.NestedArgs{base.Args{7, 8}})
+ prod, err := ar.Mul(ctx, base.NestedArgs{Args: base.Args{A: 7, B: 8}})
if err != nil {
t.Errorf("Mul: got %q, but expected no error", err)
}
diff --git a/envvar.go b/envvar.go
index 31ca4bb..bb7af0a 100644
--- a/envvar.go
+++ b/envvar.go
@@ -24,12 +24,20 @@
// See v.io/x/ref/lib/security.CreatePersistentPrincipal.
EnvCredentials = "V23_CREDENTIALS"
+ // EnvAgentPath is the name of the environment variable pointing to an
+ // agentd process containing all the credentials a principal (the blessing
+ // store, the blessing roots, possibly the private key etc.).
+ //
+ // Typically only one of EnvCredentials or EnvAgentPaths will be set in a
+ // process. If both are set, then EnvCredentials takes preference.
+ EnvAgentPath = "V23_AGENT_PATH"
+
// EnvAgentEndpoint is the name of the environment variable pointing to an
// agentd process containing all the credentials a principal (the blessing
// store, the blessing roots, possibly the private key etc.).
//
- // Typically only one of EnvCredentials or EnvAgentEndpoint will be set in a
- // process. If both are set, then EnvCredentials takes preference.
+ // EnvAgentEndpoint is deprecated. New agentd processes should use EnvAgentPath.
+ // If both are set, EnvAgentPath takes preference.
EnvAgentEndpoint = "V23_AGENT_ENDPOINT"
// EnvNamespacePrefix is the prefix of all environment variables that define a
diff --git a/examples/rps/rpsbot/player.go b/examples/rps/rpsbot/player.go
index 31ad9b0..592ffcb 100644
--- a/examples/rps/rpsbot/player.go
+++ b/examples/rps/rpsbot/player.go
@@ -131,7 +131,7 @@
opts := v.Value
n := rand.Intn(len(opts))
outer.VI(1).Infof("My turn to play. Picked %q from %v", opts[n], opts)
- if err := sender.Send(rps.PlayerActionMove{opts[n]}); err != nil {
+ if err := sender.Send(rps.PlayerActionMove{Value: opts[n]}); err != nil {
return rps.PlayResult{}, err
}
case rps.JudgeActionRoundResult:
diff --git a/examples/rps/rpsplayer/main.go b/examples/rps/rpsplayer/main.go
index 3f496f5..ad57b4f 100644
--- a/examples/rps/rpsplayer/main.go
+++ b/examples/rps/rpsplayer/main.go
@@ -243,7 +243,7 @@
fmt.Println()
fmt.Println("Choose your weapon:")
m := selectOne(opts)
- if err := game.SendStream().Send(rps.PlayerActionMove{opts[m]}); err != nil {
+ if err := game.SendStream().Send(rps.PlayerActionMove{Value: opts[m]}); err != nil {
return rps.PlayResult{}, err
}
case rps.JudgeActionScore:
diff --git a/examples/tunnel/vsh/iomanager.go b/examples/tunnel/vsh/iomanager.go
index d0f6d95..4682d94 100644
--- a/examples/tunnel/vsh/iomanager.go
+++ b/examples/tunnel/vsh/iomanager.go
@@ -130,7 +130,10 @@
logger.Global().Infof("GetWindowSize failed: %v", err)
continue
}
- outchan <- tunnel.ClientShellPacketWinSize{tunnel.WindowSize{ws.Row, ws.Col}}
+ outchan <- tunnel.ClientShellPacketWinSize{tunnel.WindowSize{
+ Rows: ws.Row,
+ Cols: ws.Col,
+ }}
}
}
diff --git a/lib/exec/exec_test.go b/lib/exec/exec_test.go
index 259b4a7..6426f8c 100644
--- a/lib/exec/exec_test.go
+++ b/lib/exec/exec_test.go
@@ -119,7 +119,7 @@
stderr, _ := cmd.StderrPipe()
cfg := vexec.NewConfig()
cfg.Set("foo", "bar")
- ph := vexec.NewParentHandle(cmd, vexec.ConfigOpt{cfg})
+ ph := vexec.NewParentHandle(cmd, vexec.ConfigOpt{Config: cfg})
err := ph.Start()
if err != nil {
t.Fatalf("testConfig: start: %v", err)
@@ -213,7 +213,7 @@
cmd[i].ExtraFiles = append(cmd[i].ExtraFiles, controlRead)
stderr[i], _ = cmd[i].StderrPipe()
tk := timekeeper.NewManualTime()
- ph[i] = vexec.NewParentHandle(cmd[i], vexec.TimeKeeperOpt{tk})
+ ph[i] = vexec.NewParentHandle(cmd[i], vexec.TimeKeeperOpt{TimeKeeper: tk})
done.Add(1)
go func() {
// For simulated slow children, wait until the parent
@@ -311,7 +311,7 @@
cmd.ExtraFiles = append(cmd.ExtraFiles, controlRead)
stderr, _ := cmd.StderrPipe()
tk := timekeeper.NewManualTime()
- ph := vexec.NewParentHandle(cmd, vexec.TimeKeeperOpt{tk})
+ ph := vexec.NewParentHandle(cmd, vexec.TimeKeeperOpt{TimeKeeper: tk})
defer clean(t, ph)
defer controlWrite.Close()
defer controlRead.Close()
@@ -352,7 +352,7 @@
t.Fatalf("%s: failed to get stderr pipe", name)
}
tk := timekeeper.NewManualTime()
- ph := vexec.NewParentHandle(cmd, vexec.TimeKeeperOpt{tk})
+ ph := vexec.NewParentHandle(cmd, vexec.TimeKeeperOpt{TimeKeeper: tk})
defer clean(t, ph)
defer controlWrite.Close()
defer controlRead.Close()
@@ -422,7 +422,7 @@
name := "exitEarly"
cmd := helperCommand(name)
tk := timekeeper.NewManualTime()
- ph := vexec.NewParentHandle(cmd, vexec.TimeKeeperOpt{tk})
+ ph := vexec.NewParentHandle(cmd, vexec.TimeKeeperOpt{TimeKeeper: tk})
err := ph.Start()
if err != nil {
t.Fatalf("%s: start: %v", name, err)
@@ -438,7 +438,7 @@
name := "testReadyAndHang"
cmd := helperCommand(name)
tk := timekeeper.NewManualTime()
- ph := vexec.NewParentHandle(cmd, vexec.TimeKeeperOpt{tk})
+ ph := vexec.NewParentHandle(cmd, vexec.TimeKeeperOpt{TimeKeeper: tk})
if err := waitForReady(t, cmd, name, 1, ph); err != nil {
t.Errorf("%s: WaitForReady: %v (%v)", name, err, ph)
}
diff --git a/lib/mgmt/model.go b/lib/mgmt/model.go
index 1aa425f..95a667f 100644
--- a/lib/mgmt/model.go
+++ b/lib/mgmt/model.go
@@ -13,6 +13,7 @@
ProtocolConfigKey = "MGMT_CHILD_PROCESS_PROTOCOL"
ParentBlessingConfigKey = "MGMT_PARENT_BLESSING_PEER_PATTERN"
SecurityAgentEndpointConfigKey = "MGMT_SECURITY_AGENT_EP"
+ SecurityAgentPathConfigKey = "MGMT_SECURITY_AGENT_PATH"
AppOriginConfigKey = "MGMT_APP_ORIGIN"
PublisherBlessingPrefixesKey = "MGMT_PUBLISHER_BLESSING_PREFIXES"
InstanceNameKey = "MGMT_INSTANCE_NAME"
diff --git a/lib/pubsub/config_test.go b/lib/pubsub/config_test.go
index f827c79..c434606 100644
--- a/lib/pubsub/config_test.go
+++ b/lib/pubsub/config_test.go
@@ -149,7 +149,11 @@
}
}
- got, want := pub.Latest("s2"), &pubsub.Stream{"s2", "eg2", nil}
+ got, want := pub.Latest("s2"), &pubsub.Stream{
+ Name: "s2",
+ Description: "eg2",
+ Latest: nil,
+ }
if !reflect.DeepEqual(got, want) {
t.Errorf("got %q, want %q", got, want)
}
diff --git a/lib/stats/sysstats/sysstats.go b/lib/stats/sysstats/sysstats.go
index 2fafa14..98c52d1 100644
--- a/lib/stats/sysstats/sysstats.go
+++ b/lib/stats/sysstats/sysstats.go
@@ -40,7 +40,10 @@
var kv []stats.KeyValue
for _, v := range os.Environ() {
if parts := strings.SplitN(v, "=", 2); len(parts) == 2 {
- kv = append(kv, stats.KeyValue{parts[0], parts[1]})
+ kv = append(kv, stats.KeyValue{
+ Key: parts[0],
+ Value: parts[1],
+ })
}
}
stats.NewMap("system/environ").Set(kv)
@@ -66,7 +69,10 @@
v := reflect.ValueOf(memstats)
kv := make([]stats.KeyValue, len(fieldNames))
for i, name := range fieldNames {
- kv[i] = stats.KeyValue{name, v.FieldByName(name).Interface()}
+ kv[i] = stats.KeyValue{
+ Key: name,
+ Value: v.FieldByName(name).Interface(),
+ }
}
mstats.Set(kv)
}
@@ -83,7 +89,10 @@
func exportMetaData() {
var kv []stats.KeyValue
for id, value := range metadata.ToMap() {
- kv = append(kv, stats.KeyValue{id, value})
+ kv = append(kv, stats.KeyValue{
+ Key: id,
+ Value: value,
+ })
}
stats.NewMap("system/metadata").Set(kv)
}
diff --git a/lib/vdl/build/build_test.go b/lib/vdl/build/build_test.go
index f3c4414..38773a1 100644
--- a/lib/vdl/build/build_test.go
+++ b/lib/vdl/build/build_test.go
@@ -579,7 +579,15 @@
func TestBuildExprs(t *testing.T) {
ttArray := vdl.ArrayType(2, vdl.Int32Type)
- ttStruct := vdl.StructType(vdl.Field{"A", vdl.Int32Type}, vdl.Field{"B", vdl.StringType})
+ ttStruct := vdl.StructType(
+ vdl.Field{
+ Name: "A",
+ Type: vdl.Int32Type,
+ }, vdl.Field{
+ Name: "B",
+ Type: vdl.StringType,
+ },
+ )
vvArray := vdl.ZeroValue(ttArray)
vvArray.Index(0).AssignInt(1)
vvArray.Index(1).AssignInt(-2)
diff --git a/lib/vdl/codegen/golang/type_test.go b/lib/vdl/codegen/golang/type_test.go
index 4a650c8..fe2e20e 100644
--- a/lib/vdl/codegen/golang/type_test.go
+++ b/lib/vdl/codegen/golang/type_test.go
@@ -180,11 +180,23 @@
tSet = vdl.SetType(vdl.StringType)
tMap = vdl.MapType(vdl.StringType, vdl.Int64Type)
tStruct = vdl.NamedType("TestStruct", vdl.StructType(
- vdl.Field{"A", vdl.StringType},
- vdl.Field{"B", vdl.Int64Type},
+ vdl.Field{
+ Name: "A",
+ Type: vdl.StringType,
+ },
+ vdl.Field{
+ Name: "B",
+ Type: vdl.Int64Type,
+ },
))
tUnion = vdl.NamedType("TestUnion", vdl.UnionType(
- vdl.Field{"A", vdl.StringType},
- vdl.Field{"B", vdl.Int64Type},
+ vdl.Field{
+ Name: "A",
+ Type: vdl.StringType,
+ },
+ vdl.Field{
+ Name: "B",
+ Type: vdl.Int64Type,
+ },
))
)
diff --git a/lib/vdl/compile/const_test.go b/lib/vdl/compile/const_test.go
index a3c0d20..2419f86 100644
--- a/lib/vdl/compile/const_test.go
+++ b/lib/vdl/compile/const_test.go
@@ -183,7 +183,10 @@
}
func makeStructTypeObjectType(name string) *vdl.Type {
- return vdl.NamedType(name, vdl.StructType(vdl.Field{"T", vdl.TypeObjectType}))
+ return vdl.NamedType(name, vdl.StructType(vdl.Field{
+ Name: "T",
+ Type: vdl.TypeObjectType,
+ }))
}
func makeStructTypeObject(name string, t *vdl.Type) *vdl.Value {
@@ -196,7 +199,10 @@
tA := vdl.NamedType("p.kg/a.A", vdl.StructType([]vdl.Field{
{"X", vdl.Int64Type}, {"Y", vdl.StringType},
}...))
- tB := vdl.NamedType("p.kg/a.B", vdl.StructType(vdl.Field{"Z", vdl.ListType(tA)}))
+ tB := vdl.NamedType("p.kg/a.B", vdl.StructType(vdl.Field{
+ Name: "Z",
+ Type: vdl.ListType(tA),
+ }))
res := vdl.ZeroValue(tB)
listv := res.StructField(0).AssignLen(2)
listv.Index(0).StructField(0).AssignInt(1)
@@ -213,7 +219,10 @@
func makeInnerEnum(label string) *vdl.Value {
tA := vdl.NamedType("p.kg/a.A", vdl.EnumType("X", "Y", "Z"))
- tB := vdl.NamedType("p.kg/a.B", vdl.StructType(vdl.Field{"A", tA}))
+ tB := vdl.NamedType("p.kg/a.B", vdl.StructType(vdl.Field{
+ Name: "A",
+ Type: tA,
+ }))
res := vdl.ZeroValue(tB)
res.StructField(0).AssignEnumLabel(label)
return res
diff --git a/lib/vdl/compile/type_test.go b/lib/vdl/compile/type_test.go
index 0009a5d..1c43299 100644
--- a/lib/vdl/compile/type_test.go
+++ b/lib/vdl/compile/type_test.go
@@ -126,7 +126,10 @@
{"Map", tp{{"a", `type Res map[int32]string`, vdl.MapType(vdl.Int32Type, vdl.StringType), ""}}},
{"Struct", tp{{"a", `type Res struct{A int32;B string}`, vdl.StructType([]vdl.Field{{"A", vdl.Int32Type}, {"B", vdl.StringType}}...), ""}}},
{"Union", tp{{"a", `type Res union{A bool;B int32;C string}`, vdl.UnionType([]vdl.Field{{"A", vdl.BoolType}, {"B", vdl.Int32Type}, {"C", vdl.StringType}}...), ""}}},
- {"Optional", tp{{"a", `type Res []?x;type x struct{A bool}`, vdl.ListType(vdl.OptionalType(namedX(vdl.StructType(vdl.Field{"A", vdl.BoolType})))), ""}}},
+ {"Optional", tp{{"a", `type Res []?x;type x struct{A bool}`, vdl.ListType(vdl.OptionalType(namedX(vdl.StructType(vdl.Field{
+ Name: "A",
+ Type: vdl.BoolType,
+ })))), ""}}},
// Test named types based on named types.
{"NBool", tp{{"a", `type Res x;type x bool`, namedX(vdl.BoolType), ""}}},
diff --git a/lib/vdl/opconst/testutil_test.go b/lib/vdl/opconst/testutil_test.go
index e16b636..886e83e 100644
--- a/lib/vdl/opconst/testutil_test.go
+++ b/lib/vdl/opconst/testutil_test.go
@@ -311,10 +311,10 @@
setStringTypeN = vdl.NamedType("nSetString", vdl.SetType(stringTypeN))
mapStringBoolType = vdl.MapType(vdl.StringType, vdl.BoolType)
mapStringBoolTypeN = vdl.NamedType("nMapStringBool", vdl.MapType(stringTypeN, boolTypeN))
- structXYZBoolType = vdl.StructType(vdl.Field{"X", vdl.BoolType}, vdl.Field{"Y", vdl.BoolType}, vdl.Field{"Z", vdl.BoolType})
- structXYZBoolTypeN = vdl.NamedType("nStructXYZBool", vdl.StructType(vdl.Field{"X", boolTypeN}, vdl.Field{"Y", boolTypeN}, vdl.Field{"Z", boolTypeN}))
- structWXBoolType = vdl.StructType(vdl.Field{"W", vdl.BoolType}, vdl.Field{"X", vdl.BoolType})
- structWXBoolTypeN = vdl.NamedType("nStructWXBool", vdl.StructType(vdl.Field{"W", boolTypeN}, vdl.Field{"X", boolTypeN}))
+ structXYZBoolType = vdl.StructType(vdl.Field{Name: "X", Type: vdl.BoolType}, vdl.Field{Name: "Y", Type: vdl.BoolType}, vdl.Field{Name: "Z", Type: vdl.BoolType})
+ structXYZBoolTypeN = vdl.NamedType("nStructXYZBool", vdl.StructType(vdl.Field{Name: "X", Type: boolTypeN}, vdl.Field{Name: "Y", Type: boolTypeN}, vdl.Field{Name: "Z", Type: boolTypeN}))
+ structWXBoolType = vdl.StructType(vdl.Field{Name: "W", Type: vdl.BoolType}, vdl.Field{Name: "X", Type: vdl.BoolType})
+ structWXBoolTypeN = vdl.NamedType("nStructWXBool", vdl.StructType(vdl.Field{Name: "W", Type: boolTypeN}, vdl.Field{Name: "X", Type: boolTypeN}))
// Composite types representing maps of strings to numbers.
mapStringUint64Type = vdl.MapType(vdl.StringType, vdl.Uint64Type)
mapStringUint64TypeN = vdl.NamedType("nMapStringUint64", vdl.MapType(stringTypeN, uint64TypeN))
@@ -324,24 +324,24 @@
mapStringFloat64TypeN = vdl.NamedType("nMapStringFloat64", vdl.MapType(stringTypeN, float64TypeN))
mapStringComplex64Type = vdl.MapType(vdl.StringType, vdl.Complex64Type)
mapStringComplex64TypeN = vdl.NamedType("nMapStringComplex64", vdl.MapType(stringTypeN, complex64TypeN))
- structVWXUint64Type = vdl.StructType(vdl.Field{"V", vdl.Uint64Type}, vdl.Field{"W", vdl.Uint64Type}, vdl.Field{"X", vdl.Uint64Type})
- structVWXUint64TypeN = vdl.NamedType("nStructVWXUint64", vdl.StructType(vdl.Field{"V", uint64TypeN}, vdl.Field{"W", uint64TypeN}, vdl.Field{"X", uint64TypeN}))
- structVWXInt64Type = vdl.StructType(vdl.Field{"V", vdl.Int64Type}, vdl.Field{"W", vdl.Int64Type}, vdl.Field{"X", vdl.Int64Type})
- structVWXInt64TypeN = vdl.NamedType("nStructVWXInt64", vdl.StructType(vdl.Field{"V", int64TypeN}, vdl.Field{"W", int64TypeN}, vdl.Field{"X", int64TypeN}))
- structVWXFloat64Type = vdl.StructType(vdl.Field{"V", vdl.Float64Type}, vdl.Field{"W", vdl.Float64Type}, vdl.Field{"X", vdl.Float64Type})
- structVWXFloat64TypeN = vdl.NamedType("nStructVWXFloat64", vdl.StructType(vdl.Field{"V", float64TypeN}, vdl.Field{"W", float64TypeN}, vdl.Field{"X", float64TypeN}))
- structVWXComplex64Type = vdl.StructType(vdl.Field{"V", vdl.Complex64Type}, vdl.Field{"W", vdl.Complex64Type}, vdl.Field{"X", vdl.Complex64Type})
- structVWXComplex64TypeN = vdl.NamedType("nStructVWXComplex64", vdl.StructType(vdl.Field{"V", complex64TypeN}, vdl.Field{"W", complex64TypeN}, vdl.Field{"X", complex64TypeN}))
- structUVUint64Type = vdl.StructType(vdl.Field{"U", vdl.Uint64Type}, vdl.Field{"V", vdl.Uint64Type})
- structUVUint64TypeN = vdl.NamedType("nStructUVUint64", vdl.StructType(vdl.Field{"U", uint64TypeN}, vdl.Field{"V", uint64TypeN}))
- structUVInt64Type = vdl.StructType(vdl.Field{"U", vdl.Int64Type}, vdl.Field{"V", vdl.Int64Type})
- structUVInt64TypeN = vdl.NamedType("nStructUVInt64", vdl.StructType(vdl.Field{"U", int64TypeN}, vdl.Field{"V", int64TypeN}))
- structUVFloat64Type = vdl.StructType(vdl.Field{"U", vdl.Float64Type}, vdl.Field{"V", vdl.Float64Type})
- structUVFloat64TypeN = vdl.NamedType("nStructUVFloat64", vdl.StructType(vdl.Field{"U", float64TypeN}, vdl.Field{"V", float64TypeN}))
- structUVComplex64Type = vdl.StructType(vdl.Field{"U", vdl.Complex64Type}, vdl.Field{"V", vdl.Complex64Type})
- structUVComplex64TypeN = vdl.NamedType("nStructUVComplex64", vdl.StructType(vdl.Field{"U", complex64TypeN}, vdl.Field{"V", complex64TypeN}))
+ structVWXUint64Type = vdl.StructType(vdl.Field{Name: "V", Type: vdl.Uint64Type}, vdl.Field{Name: "W", Type: vdl.Uint64Type}, vdl.Field{Name: "X", Type: vdl.Uint64Type})
+ structVWXUint64TypeN = vdl.NamedType("nStructVWXUint64", vdl.StructType(vdl.Field{Name: "V", Type: uint64TypeN}, vdl.Field{Name: "W", Type: uint64TypeN}, vdl.Field{Name: "X", Type: uint64TypeN}))
+ structVWXInt64Type = vdl.StructType(vdl.Field{Name: "V", Type: vdl.Int64Type}, vdl.Field{Name: "W", Type: vdl.Int64Type}, vdl.Field{Name: "X", Type: vdl.Int64Type})
+ structVWXInt64TypeN = vdl.NamedType("nStructVWXInt64", vdl.StructType(vdl.Field{Name: "V", Type: int64TypeN}, vdl.Field{Name: "W", Type: int64TypeN}, vdl.Field{Name: "X", Type: int64TypeN}))
+ structVWXFloat64Type = vdl.StructType(vdl.Field{Name: "V", Type: vdl.Float64Type}, vdl.Field{Name: "W", Type: vdl.Float64Type}, vdl.Field{Name: "X", Type: vdl.Float64Type})
+ structVWXFloat64TypeN = vdl.NamedType("nStructVWXFloat64", vdl.StructType(vdl.Field{Name: "V", Type: float64TypeN}, vdl.Field{Name: "W", Type: float64TypeN}, vdl.Field{Name: "X", Type: float64TypeN}))
+ structVWXComplex64Type = vdl.StructType(vdl.Field{Name: "V", Type: vdl.Complex64Type}, vdl.Field{Name: "W", Type: vdl.Complex64Type}, vdl.Field{Name: "X", Type: vdl.Complex64Type})
+ structVWXComplex64TypeN = vdl.NamedType("nStructVWXComplex64", vdl.StructType(vdl.Field{Name: "V", Type: complex64TypeN}, vdl.Field{Name: "W", Type: complex64TypeN}, vdl.Field{Name: "X", Type: complex64TypeN}))
+ structUVUint64Type = vdl.StructType(vdl.Field{Name: "U", Type: vdl.Uint64Type}, vdl.Field{Name: "V", Type: vdl.Uint64Type})
+ structUVUint64TypeN = vdl.NamedType("nStructUVUint64", vdl.StructType(vdl.Field{Name: "U", Type: uint64TypeN}, vdl.Field{Name: "V", Type: uint64TypeN}))
+ structUVInt64Type = vdl.StructType(vdl.Field{Name: "U", Type: vdl.Int64Type}, vdl.Field{Name: "V", Type: vdl.Int64Type})
+ structUVInt64TypeN = vdl.NamedType("nStructUVInt64", vdl.StructType(vdl.Field{Name: "U", Type: int64TypeN}, vdl.Field{Name: "V", Type: int64TypeN}))
+ structUVFloat64Type = vdl.StructType(vdl.Field{Name: "U", Type: vdl.Float64Type}, vdl.Field{Name: "V", Type: vdl.Float64Type})
+ structUVFloat64TypeN = vdl.NamedType("nStructUVFloat64", vdl.StructType(vdl.Field{Name: "U", Type: float64TypeN}, vdl.Field{Name: "V", Type: float64TypeN}))
+ structUVComplex64Type = vdl.StructType(vdl.Field{Name: "U", Type: vdl.Complex64Type}, vdl.Field{Name: "V", Type: vdl.Complex64Type})
+ structUVComplex64TypeN = vdl.NamedType("nStructUVComplex64", vdl.StructType(vdl.Field{Name: "U", Type: complex64TypeN}, vdl.Field{Name: "V", Type: complex64TypeN}))
- structAIntType = vdl.StructType(vdl.Field{"A", vdl.Int64Type})
+ structAIntType = vdl.StructType(vdl.Field{Name: "A", Type: vdl.Int64Type})
structAIntTypeN = vdl.NamedType("nStructA", structAIntType)
// Types that cannot be converted to sets. Although we represent sets as
@@ -351,8 +351,8 @@
emptyTypeN = vdl.NamedType("nEmpty", vdl.StructType())
mapStringEmptyType = vdl.MapType(vdl.StringType, emptyType)
mapStringEmptyTypeN = vdl.NamedType("nMapStringEmpty", vdl.MapType(stringTypeN, emptyTypeN))
- structXYZEmptyType = vdl.StructType(vdl.Field{"X", emptyType}, vdl.Field{"Y", emptyType}, vdl.Field{"Z", emptyType})
- structXYZEmptyTypeN = vdl.NamedType("nStructXYZEmpty", vdl.StructType(vdl.Field{"X", emptyTypeN}, vdl.Field{"Y", emptyTypeN}, vdl.Field{"Z", emptyTypeN}))
+ structXYZEmptyType = vdl.StructType(vdl.Field{Name: "X", Type: emptyType}, vdl.Field{Name: "Y", Type: emptyType}, vdl.Field{Name: "Z", Type: emptyType})
+ structXYZEmptyTypeN = vdl.NamedType("nStructXYZEmpty", vdl.StructType(vdl.Field{Name: "X", Type: emptyTypeN}, vdl.Field{Name: "Y", Type: emptyTypeN}, vdl.Field{Name: "Z", Type: emptyTypeN}))
)
func anyValue(x *vdl.Value) *vdl.Value { return vdl.ZeroValue(vdl.AnyType).Assign(x) }
diff --git a/lib/vdl/parse/parse_test.go b/lib/vdl/parse/parse_test.go
index 6e3ba87..7cbe7f1 100644
--- a/lib/vdl/parse/parse_test.go
+++ b/lib/vdl/parse/parse_test.go
@@ -645,14 +645,26 @@
const box = ^3`,
&parse.File{BaseName: "testfile", PackageDef: np("testpkg", 1, 9),
ConstDefs: []*parse.ConstDef{
- {NamePos: np("foo", 2, 7), Expr: &parse.ConstUnaryOp{"!",
- cn("false", 2, 14), pos(2, 13)}},
- {NamePos: np("bar", 3, 7), Expr: &parse.ConstUnaryOp{"+",
- cl(big.NewInt(1), 3, 14), pos(3, 13)}},
- {NamePos: np("baz", 4, 7), Expr: &parse.ConstUnaryOp{"-",
- cl(big.NewInt(2), 4, 14), pos(4, 13)}},
- {NamePos: np("box", 5, 7), Expr: &parse.ConstUnaryOp{"^",
- cl(big.NewInt(3), 5, 14), pos(5, 13)}}}},
+ {NamePos: np("foo", 2, 7), Expr: &parse.ConstUnaryOp{
+ Op: "!",
+ Expr: cn("false", 2, 14),
+ P: pos(2, 13)},
+ },
+ {NamePos: np("bar", 3, 7), Expr: &parse.ConstUnaryOp{
+ Op: "+",
+ Expr: cl(big.NewInt(1), 3, 14),
+ P: pos(3, 13)},
+ },
+ {NamePos: np("baz", 4, 7), Expr: &parse.ConstUnaryOp{
+ Op: "-",
+ Expr: cl(big.NewInt(2), 4, 14),
+ P: pos(4, 13)},
+ },
+ {NamePos: np("box", 5, 7), Expr: &parse.ConstUnaryOp{
+ Op: "^",
+ Expr: cl(big.NewInt(3), 5, 14),
+ P: pos(5, 13),
+ }}}},
nil},
{
"TypeConvConst",
@@ -661,10 +673,16 @@
const bar = pkg.box(false)`,
&parse.File{BaseName: "testfile", PackageDef: np("testpkg", 1, 9),
ConstDefs: []*parse.ConstDef{
- {NamePos: np("foo", 2, 7), Expr: &parse.ConstTypeConv{tn("baz", 2, 13),
- cn("true", 2, 17), pos(2, 13)}},
- {NamePos: np("bar", 3, 7), Expr: &parse.ConstTypeConv{tn("pkg.box", 3, 13),
- cn("false", 3, 21), pos(3, 13)}}}},
+ {NamePos: np("foo", 2, 7), Expr: &parse.ConstTypeConv{
+ Type: tn("baz", 2, 13),
+ Expr: cn("true", 2, 17),
+ P: pos(2, 13),
+ }},
+ {NamePos: np("bar", 3, 7), Expr: &parse.ConstTypeConv{
+ Type: tn("pkg.box", 3, 13),
+ Expr: cn("false", 3, 21),
+ P: pos(3, 13),
+ }}}},
nil},
{
"TypeObjectConst",
@@ -673,10 +691,14 @@
const bar = typeobject(pkg.box)`,
&parse.File{BaseName: "testfile", PackageDef: np("testpkg", 1, 9),
ConstDefs: []*parse.ConstDef{
- {NamePos: np("foo", 2, 7), Expr: &parse.ConstTypeObject{tn("bool", 2, 24),
- pos(2, 13)}},
- {NamePos: np("bar", 3, 7), Expr: &parse.ConstTypeObject{tn("pkg.box", 3, 24),
- pos(3, 13)}}}},
+ {NamePos: np("foo", 2, 7), Expr: &parse.ConstTypeObject{
+ Type: tn("bool", 2, 24),
+ P: pos(2, 13),
+ }},
+ {NamePos: np("bar", 3, 7), Expr: &parse.ConstTypeObject{
+ Type: tn("pkg.box", 3, 24),
+ P: pos(3, 13),
+ }}}},
nil},
{
"BinaryOpConst",
@@ -703,58 +725,130 @@
ConstDefs: []*parse.ConstDef{
{NamePos: np("a", 2, 7),
Expr: &parse.ConstBinaryOp{
- "||", cn("true", 2, 11), cn("false", 2, 19), pos(2, 16)}},
+ Op: "||",
+ Lexpr: cn("true", 2, 11),
+ Rexpr: cn("false", 2, 19),
+ P: pos(2, 16),
+ }},
{NamePos: np("b", 3, 7),
Expr: &parse.ConstBinaryOp{
- "&&", cn("true", 3, 11), cn("false", 3, 19), pos(3, 16)}},
+ Op: "&&",
+ Lexpr: cn("true", 3, 11),
+ Rexpr: cn("false", 3, 19),
+ P: pos(3, 16),
+ }},
{NamePos: np("c", 4, 7),
- Expr: &parse.ConstBinaryOp{"<", cl(big.NewInt(1), 4, 11),
- cl(big.NewInt(2), 4, 15), pos(4, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "<",
+ Lexpr: cl(big.NewInt(1), 4, 11),
+ Rexpr: cl(big.NewInt(2), 4, 15),
+ P: pos(4, 13),
+ }},
{NamePos: np("d", 5, 7),
- Expr: &parse.ConstBinaryOp{">", cl(big.NewInt(3), 5, 11),
- cl(big.NewInt(4), 5, 15), pos(5, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: ">",
+ Lexpr: cl(big.NewInt(3), 5, 11),
+ Rexpr: cl(big.NewInt(4), 5, 15),
+ P: pos(5, 13),
+ }},
{NamePos: np("e", 6, 7),
- Expr: &parse.ConstBinaryOp{"<=", cl(big.NewInt(5), 6, 11),
- cl(big.NewInt(6), 6, 16), pos(6, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "<=",
+ Lexpr: cl(big.NewInt(5), 6, 11),
+ Rexpr: cl(big.NewInt(6), 6, 16),
+ P: pos(6, 13),
+ }},
{NamePos: np("f", 7, 7),
- Expr: &parse.ConstBinaryOp{">=", cl(big.NewInt(7), 7, 11),
- cl(big.NewInt(8), 7, 16), pos(7, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: ">=",
+ Lexpr: cl(big.NewInt(7), 7, 11),
+ Rexpr: cl(big.NewInt(8), 7, 16),
+ P: pos(7, 13),
+ }},
{NamePos: np("g", 8, 7),
- Expr: &parse.ConstBinaryOp{"!=", cl(big.NewInt(9), 8, 11),
- cl(big.NewInt(8), 8, 16), pos(8, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "!=",
+ Lexpr: cl(big.NewInt(9), 8, 11),
+ Rexpr: cl(big.NewInt(8), 8, 16),
+ P: pos(8, 13),
+ }},
{NamePos: np("h", 9, 7),
- Expr: &parse.ConstBinaryOp{"==", cl(big.NewInt(7), 9, 11),
- cl(big.NewInt(6), 9, 16), pos(9, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "==",
+ Lexpr: cl(big.NewInt(7), 9, 11),
+ Rexpr: cl(big.NewInt(6), 9, 16),
+ P: pos(9, 13),
+ }},
{NamePos: np("i", 10, 7),
- Expr: &parse.ConstBinaryOp{"+", cl(big.NewInt(5), 10, 11),
- cl(big.NewInt(4), 10, 15), pos(10, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "+",
+ Lexpr: cl(big.NewInt(5), 10, 11),
+ Rexpr: cl(big.NewInt(4), 10, 15),
+ P: pos(10, 13),
+ }},
{NamePos: np("j", 11, 7),
- Expr: &parse.ConstBinaryOp{"-", cl(big.NewInt(3), 11, 11),
- cl(big.NewInt(2), 11, 15), pos(11, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "-",
+ Lexpr: cl(big.NewInt(3), 11, 11),
+ Rexpr: cl(big.NewInt(2), 11, 15),
+ P: pos(11, 13),
+ }},
{NamePos: np("k", 12, 7),
- Expr: &parse.ConstBinaryOp{"*", cl(big.NewInt(1), 12, 11),
- cl(big.NewInt(2), 12, 15), pos(12, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "*",
+ Lexpr: cl(big.NewInt(1), 12, 11),
+ Rexpr: cl(big.NewInt(2), 12, 15),
+ P: pos(12, 13),
+ }},
{NamePos: np("l", 13, 7),
- Expr: &parse.ConstBinaryOp{"/", cl(big.NewInt(3), 13, 11),
- cl(big.NewInt(4), 13, 15), pos(13, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "/",
+ Lexpr: cl(big.NewInt(3), 13, 11),
+ Rexpr: cl(big.NewInt(4), 13, 15),
+ P: pos(13, 13),
+ }},
{NamePos: np("m", 14, 7),
- Expr: &parse.ConstBinaryOp{"%", cl(big.NewInt(5), 14, 11),
- cl(big.NewInt(6), 14, 15), pos(14, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "%",
+ Lexpr: cl(big.NewInt(5), 14, 11),
+ Rexpr: cl(big.NewInt(6), 14, 15),
+ P: pos(14, 13),
+ }},
{NamePos: np("n", 15, 7),
- Expr: &parse.ConstBinaryOp{"|", cl(big.NewInt(7), 15, 11),
- cl(big.NewInt(8), 15, 15), pos(15, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "|",
+ Lexpr: cl(big.NewInt(7), 15, 11),
+ Rexpr: cl(big.NewInt(8), 15, 15),
+ P: pos(15, 13),
+ }},
{NamePos: np("o", 16, 7),
- Expr: &parse.ConstBinaryOp{"&", cl(big.NewInt(9), 16, 11),
- cl(big.NewInt(8), 16, 15), pos(16, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "&",
+ Lexpr: cl(big.NewInt(9), 16, 11),
+ Rexpr: cl(big.NewInt(8), 16, 15),
+ P: pos(16, 13),
+ }},
{NamePos: np("p", 17, 7),
- Expr: &parse.ConstBinaryOp{"^", cl(big.NewInt(7), 17, 11),
- cl(big.NewInt(6), 17, 15), pos(17, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "^",
+ Lexpr: cl(big.NewInt(7), 17, 11),
+ Rexpr: cl(big.NewInt(6), 17, 15),
+ P: pos(17, 13),
+ }},
{NamePos: np("q", 18, 7),
- Expr: &parse.ConstBinaryOp{"<<", cl(big.NewInt(5), 18, 11),
- cl(big.NewInt(4), 18, 16), pos(18, 13)}},
+ Expr: &parse.ConstBinaryOp{
+ Op: "<<",
+ Lexpr: cl(big.NewInt(5), 18, 11),
+ Rexpr: cl(big.NewInt(4), 18, 16),
+ P: pos(18, 13),
+ }},
{NamePos: np("r", 19, 7),
- Expr: &parse.ConstBinaryOp{">>", cl(big.NewInt(3), 19, 11),
- cl(big.NewInt(2), 19, 16), pos(19, 13)}}}},
+ Expr: &parse.ConstBinaryOp{
+ Op: ">>",
+ Lexpr: cl(big.NewInt(3), 19, 11),
+ Rexpr: cl(big.NewInt(2), 19, 16),
+ P: pos(19, 13),
+ }}}},
nil},
{
"FAILConstOnlyName",
diff --git a/runtime/internal/naming/namespace/all_test.go b/runtime/internal/naming/namespace/all_test.go
index 0844c4f..04febd1 100644
--- a/runtime/internal/naming/namespace/all_test.go
+++ b/runtime/internal/naming/namespace/all_test.go
@@ -137,11 +137,11 @@
switch t.suffix {
case "":
if n := "level1"; m.Match(n) {
- call.SendStream().Send(naming.GlobChildrenReplyName{n})
+ call.SendStream().Send(naming.GlobChildrenReplyName{Value: n})
}
case "level1":
if n := "level2"; m.Match(n) {
- call.SendStream().Send(naming.GlobChildrenReplyName{n})
+ call.SendStream().Send(naming.GlobChildrenReplyName{Value: n})
}
default:
return nil
diff --git a/runtime/internal/naming/namespace/cache_test.go b/runtime/internal/naming/namespace/cache_test.go
index b3606f8..457ea85 100644
--- a/runtime/internal/naming/namespace/cache_test.go
+++ b/runtime/internal/naming/namespace/cache_test.go
@@ -22,7 +22,7 @@
}
func future(secs uint32) vdltime.Deadline {
- return vdltime.Deadline{time.Now().Add(time.Duration(secs) * time.Second)}
+ return vdltime.Deadline{Time: time.Now().Add(time.Duration(secs) * time.Second)}
}
// TestCache tests the cache directly rather than via the namespace methods.
@@ -89,7 +89,7 @@
func TestCacheTTL(t *testing.T) {
ctx, cancel := test.TestContext()
defer cancel()
- before := vdltime.Deadline{time.Now()}
+ before := vdltime.Deadline{Time: time.Now()}
c := newTTLCache().(*ttlCache)
// Fill cache.
e := &naming.MountEntry{Servers: []naming.MountedServer{naming.MountedServer{Server: "the rain in spain", Deadline: future(3000)}}}
diff --git a/runtime/internal/naming/namespace/glob.go b/runtime/internal/naming/namespace/glob.go
index e5ca02e..ae24caf 100644
--- a/runtime/internal/naming/namespace/glob.go
+++ b/runtime/internal/naming/namespace/glob.go
@@ -180,7 +180,7 @@
// If no tasks are running, return.
if t.error != nil {
if !notAnMT(t.error) {
- reply <- &naming.GlobReplyError{naming.GlobError{Name: naming.Join(prefix, t.me.Name), Error: t.error}}
+ reply <- &naming.GlobReplyError{Value: naming.GlobError{Name: naming.Join(prefix, t.me.Name), Error: t.error}}
}
inFlight--
continue
@@ -190,7 +190,7 @@
if t.er != nil {
x := *t.er
x.Name = naming.Join(prefix, x.Name)
- reply <- &naming.GlobReplyError{x}
+ reply <- &naming.GlobReplyError{Value: x}
continue
}
@@ -205,7 +205,7 @@
if suffix.Len() == 0 && t.depth != 0 {
x := *t.me
x.Name = naming.Join(prefix, x.Name)
- reply <- &naming.GlobReplyEntry{x}
+ reply <- &naming.GlobReplyEntry{Value: x}
}
// If the pattern is finished (so we're only querying about the root on the
diff --git a/runtime/internal/naming/namespace/namespace.go b/runtime/internal/naming/namespace/namespace.go
index dc8db7c..1a9f109 100644
--- a/runtime/internal/naming/namespace/namespace.go
+++ b/runtime/internal/naming/namespace/namespace.go
@@ -131,7 +131,7 @@
func (ns *namespace) rootMountEntry(name string, opts ...naming.NamespaceOpt) (*naming.MountEntry, bool) {
_, name = security.SplitPatternName(naming.Clean(name))
e := new(naming.MountEntry)
- deadline := vdltime.Deadline{time.Now().Add(time.Hour)} // plenty of time for a call
+ deadline := vdltime.Deadline{Time: time.Now().Add(time.Hour)} // plenty of time for a call
address, suffix := naming.SplitAddressName(name)
if len(address) == 0 {
e.ServesMountTable = true
diff --git a/runtime/internal/rpc/blessings_cache.go b/runtime/internal/rpc/blessings_cache.go
index a6e9d92..7b201bb 100644
--- a/runtime/internal/rpc/blessings_cache.go
+++ b/runtime/internal/rpc/blessings_cache.go
@@ -122,7 +122,7 @@
return rpc.BlessingsRequest{Key: val.id}
}
// otherwise we still need to send both key and blessings, but we must ensure that we send the same key.
- return rpc.BlessingsRequest{val.id, &blessings}
+ return rpc.BlessingsRequest{Key: val.id, Blessings: &blessings}
}
// nextIdLocked creates a new id for inserting blessings. It must be called after acquiring a writer lock.
diff --git a/runtime/internal/rpc/client.go b/runtime/internal/rpc/client.go
index 26b7e91..1aad0f8 100644
--- a/runtime/internal/rpc/client.go
+++ b/runtime/internal/rpc/client.go
@@ -850,7 +850,7 @@
Suffix: suffix,
Method: method,
NumPosArgs: uint64(len(args)),
- Deadline: vtime.Deadline{deadline},
+ Deadline: vtime.Deadline{Time: deadline},
GrantedBlessings: fc.grantedBlessings,
Blessings: blessingsRequest,
Discharges: fc.discharges,
@@ -909,7 +909,10 @@
}
}
if id := verror.ErrorID(err); id != verror.ErrUnknown.ID {
- return verror.IDAction{id, verror.Action(err)}, err
+ return verror.IDAction{
+ ID: id,
+ Action: verror.Action(err),
+ }, err
}
return verror.ErrBadProtocol, err
}
diff --git a/runtime/internal/rpc/full_test.go b/runtime/internal/rpc/full_test.go
index 9c26e2b..2da28c4 100644
--- a/runtime/internal/rpc/full_test.go
+++ b/runtime/internal/rpc/full_test.go
@@ -530,8 +530,12 @@
{bTwoBlessings, "mountpoint/server", O{options.AllowedServersPolicy{"root/other"}}, noErrID, ""},
// Test the ServerPublicKey option.
- {bOther, "mountpoint/server", O{options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{bOther.PublicKey()}}, noErrID, ""},
- {bOther, "mountpoint/server", O{options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{testutil.NewPrincipal("irrelevant").PublicKey()}}, verror.ErrNotTrusted, publicKeyErr},
+ {bOther, "mountpoint/server", O{options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{
+ PublicKey: bOther.PublicKey(),
+ }}, noErrID, ""},
+ {bOther, "mountpoint/server", O{options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{
+ PublicKey: testutil.NewPrincipal("irrelevant").PublicKey(),
+ }}, verror.ErrNotTrusted, publicKeyErr},
// Test the "paranoid" names, where the pattern is provided in the name.
{bServer, "__(root/server)/mountpoint/server", nil, noErrID, ""},
@@ -1736,7 +1740,7 @@
// to act as batman (as opposed to using the default blessing).
ns := tnaming.NewSimpleNamespace()
- defer runServer(t, sctx, ns, "mountpoint/batman", &testServer{}, options.ServerBlessings{batman}).Shutdown()
+ defer runServer(t, sctx, ns, "mountpoint/batman", &testServer{}, options.ServerBlessings{Blessings: batman}).Shutdown()
defer runServer(t, sctx, ns, "mountpoint/default", &testServer{}).Shutdown()
// And finally, make an RPC and see that the client sees "batman"
@@ -2015,11 +2019,15 @@
defer client.Close()
// The call should succeed when the server presents the same public as the opt...
- if _, err = client.StartCall(cctx, mountName, "Closure", nil, options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{pserver.PublicKey()}); err != nil {
+ if _, err = client.StartCall(cctx, mountName, "Closure", nil, options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{
+ PublicKey: pserver.PublicKey(),
+ }); err != nil {
t.Errorf("Expected call to succeed but got %v", err)
}
// ...but fail if they differ.
- if _, err = client.StartCall(cctx, mountName, "Closure", nil, options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{pother.PublicKey()}); verror.ErrorID(err) != verror.ErrNotTrusted.ID {
+ if _, err = client.StartCall(cctx, mountName, "Closure", nil, options.SkipServerEndpointAuthorization{}, options.ServerPublicKey{
+ PublicKey: pother.PublicKey(),
+ }); verror.ErrorID(err) != verror.ErrNotTrusted.ID {
t.Errorf("got %v, want %v", verror.ErrorID(err), verror.ErrNotTrusted.ID)
}
}
diff --git a/runtime/internal/rpc/reserved.go b/runtime/internal/rpc/reserved.go
index c82aaa0..35adc61 100644
--- a/runtime/internal/rpc/reserved.go
+++ b/runtime/internal/rpc/reserved.go
@@ -230,7 +230,7 @@
if state.depth > maxRecursiveGlobDepth {
ctx.Errorf("rpc Glob: exceeded recursion limit (%d): %q", maxRecursiveGlobDepth, suffix)
subcall.Send(naming.GlobReplyError{
- naming.GlobError{Name: state.name, Error: reserved.NewErrGlobMaxRecursionReached(ctx)},
+ Value: naming.GlobError{Name: state.name, Error: reserved.NewErrGlobMaxRecursionReached(ctx)},
})
continue
}
@@ -238,14 +238,14 @@
if err != nil {
ctx.VI(3).Infof("rpc Glob: Lookup failed for %q: %v", suffix, err)
subcall.Send(naming.GlobReplyError{
- naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrNoExist, ctx, err)},
+ Value: naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrNoExist, ctx, err)},
})
continue
}
if obj == nil {
ctx.VI(3).Infof("rpc Glob: object not found for %q", suffix)
subcall.Send(naming.GlobReplyError{
- naming.GlobError{Name: state.name, Error: verror.New(verror.ErrNoExist, ctx, "nil object")},
+ Value: naming.GlobError{Name: state.name, Error: verror.New(verror.ErrNoExist, ctx, "nil object")},
})
continue
}
@@ -263,17 +263,19 @@
if err != nil {
ctx.VI(3).Infof("rpc Glob: object for %q cannot be converted to invoker: %v", suffix, err)
subcall.Send(naming.GlobReplyError{
- naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrInternal, ctx, err)},
+ Value: naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrInternal, ctx, err)},
})
continue
}
gs := invoker.Globber()
if gs == nil || (gs.AllGlobber == nil && gs.ChildrenGlobber == nil && gs.AllGlobberX == nil && gs.ChildrenGlobberX == nil) {
if state.glob.Len() == 0 {
- subcall.Send(naming.GlobReplyEntry{naming.MountEntry{Name: state.name, IsLeaf: true}})
+ subcall.Send(naming.GlobReplyEntry{
+ Value: naming.MountEntry{Name: state.name, IsLeaf: true},
+ })
} else {
subcall.Send(naming.GlobReplyError{
- naming.GlobError{Name: state.name, Error: reserved.NewErrGlobNotImplemented(ctx)},
+ Value: naming.GlobError{Name: state.name, Error: reserved.NewErrGlobNotImplemented(ctx)},
})
}
continue
@@ -304,7 +306,9 @@
}
if err := gs.AllGlobber.Glob__(ctx, &globServerCall{subcall, send}, state.glob); err != nil {
ctx.VI(3).Infof("rpc Glob: %q.Glob(%q) failed: %v", suffix, state.glob, err)
- subcall.Send(naming.GlobReplyError{naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrInternal, ctx, err)}})
+ subcall.Send(naming.GlobReplyError{
+ Value: naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrInternal, ctx, err)},
+ })
}
continue
}
@@ -313,7 +317,9 @@
depth := state.depth
if state.glob.Len() == 0 {
// The glob pattern matches the current object.
- subcall.Send(naming.GlobReplyEntry{naming.MountEntry{Name: state.name}})
+ subcall.Send(naming.GlobReplyEntry{
+ Value: naming.MountEntry{Name: state.name},
+ })
if state.glob.Recursive() {
// This is a recursive pattern. Make sure we don't recurse forever.
depth++
@@ -342,18 +348,22 @@
queue = append(queue, gState{next, tail, depth})
case naming.GlobChildrenReplyError:
v.Value.Name = naming.Join(state.name, v.Value.Name)
- return subcall.Send(naming.GlobReplyError{v.Value})
+ return subcall.Send(naming.GlobReplyError{Value: v.Value})
}
return nil
}
if err := gs.ChildrenGlobber.GlobChildren__(ctx, &globChildrenServerCall{subcall, send}, matcher); err != nil {
- subcall.Send(naming.GlobReplyError{naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrInternal, ctx, err)}})
+ subcall.Send(naming.GlobReplyError{
+ Value: naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrInternal, ctx, err)},
+ })
}
continue
}
}
if someMatchesOmitted {
- call.Send(naming.GlobReplyError{naming.GlobError{Error: reserved.NewErrGlobMatchesOmitted(ctx)}})
+ call.Send(naming.GlobReplyError{
+ Value: naming.GlobError{Error: reserved.NewErrGlobMatchesOmitted(ctx)},
+ })
}
return nil
}
diff --git a/runtime/internal/rpc/server.go b/runtime/internal/rpc/server.go
index 1e30282..9f97089 100644
--- a/runtime/internal/rpc/server.go
+++ b/runtime/internal/rpc/server.go
@@ -288,7 +288,11 @@
}
status.Proxies = make([]rpc.ProxyStatus, 0, len(s.proxies))
for k, v := range s.proxies {
- status.Proxies = append(status.Proxies, rpc.ProxyStatus{k, v.endpoint, v.err})
+ status.Proxies = append(status.Proxies, rpc.ProxyStatus{
+ Proxy: k,
+ Endpoint: v.endpoint,
+ Error: v.err,
+ })
}
return status
}
diff --git a/runtime/internal/rpc/server_authorizer_test.go b/runtime/internal/rpc/server_authorizer_test.go
index 68afdec..be56861 100644
--- a/runtime/internal/rpc/server_authorizer_test.go
+++ b/runtime/internal/rpc/server_authorizer_test.go
@@ -94,7 +94,7 @@
// Only otherAli is authorized (since only pother's public key is
// authorized)
[]string{"ali"},
- newServerAuthorizer("", options.ServerPublicKey{pother.PublicKey()}),
+ newServerAuthorizer("", options.ServerPublicKey{PublicKey: pother.PublicKey()}),
[]security.Blessings{otherAli},
[]security.Blessings{ali, bob, che},
},
diff --git a/runtime/internal/rpc/stream/benchmark/dial_vc.go b/runtime/internal/rpc/stream/benchmark/dial_vc.go
index e0cbe02..c376783 100644
--- a/runtime/internal/rpc/stream/benchmark/dial_vc.go
+++ b/runtime/internal/rpc/stream/benchmark/dial_vc.go
@@ -47,7 +47,7 @@
}
// Create one VC to prevent the underlying VIF from being closed.
- _, err = client.Dial(ctx, ep, vc.IdleTimeout{0})
+ _, err = client.Dial(ctx, ep, vc.IdleTimeout{Duration: 0})
if err != nil {
b.Fatal(err)
}
diff --git a/runtime/internal/rpc/stream/crypto/crypto_test.go b/runtime/internal/rpc/stream/crypto/crypto_test.go
index ed27061..b44af89 100644
--- a/runtime/internal/rpc/stream/crypto/crypto_test.go
+++ b/runtime/internal/rpc/stream/crypto/crypto_test.go
@@ -38,7 +38,7 @@
func TestNull(t *testing.T) {
crypter := NewNullCrypter()
quickTest(t, crypter, crypter)
- crypter.String() // Only to test that String does not crash.
+ _ = crypter.String() // Only to test that String does not crash.
}
func TestNullWithChannelBinding(t *testing.T) {
@@ -48,13 +48,13 @@
if got := crypter.ChannelBinding(); !bytes.Equal(cb, got) {
t.Errorf("Unexpected channel binding; got %q, want %q", got, cb)
}
- crypter.String() // Only to test that String does not crash.
+ _ = crypter.String() // Only to test that String does not crash.
}
func testSimple(t *testing.T, c1, c2 Crypter) {
// Execute String just to check that it does not crash.
- c1.String()
- c2.String()
+ _ = c1.String()
+ _ = c2.String()
if t.Failed() {
return
}
diff --git a/runtime/internal/rpc/stream/manager/listener.go b/runtime/internal/rpc/stream/manager/listener.go
index a25c514..64a7819 100644
--- a/runtime/internal/rpc/stream/manager/listener.go
+++ b/runtime/internal/rpc/stream/manager/listener.go
@@ -109,7 +109,7 @@
// Set the default idle timeout for VC. But for "unixfd", we do not set
// the idle timeout since we cannot reconnect it.
if ln.netLn.Addr().Network() != "unixfd" {
- opts = append([]stream.ListenerOpt{vc.IdleTimeout{defaultIdleTimeout}}, opts...)
+ opts = append([]stream.ListenerOpt{vc.IdleTimeout{Duration: defaultIdleTimeout}}, opts...)
}
ln.netLoop.Add(1)
@@ -171,7 +171,7 @@
func (ln *netListener) netAcceptLoop(blessings security.Blessings, opts []stream.ListenerOpt) {
defer ln.netLoop.Done()
- opts = append([]stream.ListenerOpt{vc.StartTimeout{defaultStartTimeout}}, opts...)
+ opts = append([]stream.ListenerOpt{vc.StartTimeout{Duration: defaultStartTimeout}}, opts...)
for {
conn, err := ln.netLn.Accept()
if isTemporaryError(err) {
@@ -319,7 +319,7 @@
return nil, nil, err
}
// Prepend the default idle timeout for VC.
- opts = append([]stream.ListenerOpt{vc.IdleTimeout{defaultIdleTimeout}}, opts...)
+ opts = append([]stream.ListenerOpt{vc.IdleTimeout{Duration: defaultIdleTimeout}}, opts...)
if err := vf.StartAccepting(opts...); err != nil {
return nil, nil, verror.New(stream.ErrNetwork, nil, verror.New(errAlreadyConnected, nil, vf, err))
}
diff --git a/runtime/internal/rpc/stream/manager/manager.go b/runtime/internal/rpc/stream/manager/manager.go
index 1b63a9f..7b3a7ad 100644
--- a/runtime/internal/rpc/stream/manager/manager.go
+++ b/runtime/internal/rpc/stream/manager/manager.go
@@ -169,7 +169,7 @@
return nil, err
}
- opts = append([]stream.VCOpt{vc.StartTimeout{defaultStartTimeout}}, opts...)
+ opts = append([]stream.VCOpt{vc.StartTimeout{Duration: defaultStartTimeout}}, opts...)
vf, err = vif.InternalNewDialedVIF(ctx, conn, m.rid, nil, m.deleteVIF, opts...)
if err != nil {
conn.Close()
@@ -187,7 +187,7 @@
if err != nil {
return nil, err
}
- opts = append([]stream.VCOpt{vc.IdleTimeout{defaultIdleTimeout}}, opts...)
+ opts = append([]stream.VCOpt{vc.IdleTimeout{Duration: defaultIdleTimeout}}, opts...)
vc, err := vf.Dial(ctx, remote, opts...)
if !retry || verror.ErrorID(err) != stream.ErrAborted.ID {
return vc, err
diff --git a/runtime/internal/rpc/stream/manager/manager_test.go b/runtime/internal/rpc/stream/manager/manager_test.go
index 622c7af..0d050fd 100644
--- a/runtime/internal/rpc/stream/manager/manager_test.go
+++ b/runtime/internal/rpc/stream/manager/manager_test.go
@@ -427,7 +427,7 @@
var (
server = InternalNew(ctx, naming.FixedRoutingID(0x55555555))
pserver = testutil.NewPrincipal("server")
- lopts = []stream.ListenerOpt{vc.StartTimeout{startTime}}
+ lopts = []stream.ListenerOpt{vc.StartTimeout{Duration: startTime}}
)
sctx, _ := v23.WithPrincipal(ctx, pserver)
@@ -489,9 +489,9 @@
)
if testServer {
- lopts = []stream.ListenerOpt{vc.IdleTimeout{idleTime}}
+ lopts = []stream.ListenerOpt{vc.IdleTimeout{Duration: idleTime}}
} else {
- opts = []stream.VCOpt{vc.IdleTimeout{idleTime}}
+ opts = []stream.VCOpt{vc.IdleTimeout{Duration: idleTime}}
}
// Pause the idle timers.
diff --git a/runtime/internal/rpc/stream/proxy/proxy_test.go b/runtime/internal/rpc/stream/proxy/proxy_test.go
index a16a51f..23fc033 100644
--- a/runtime/internal/rpc/stream/proxy/proxy_test.go
+++ b/runtime/internal/rpc/stream/proxy/proxy_test.go
@@ -368,9 +368,9 @@
lopts []stream.ListenerOpt
)
if testServer {
- lopts = []stream.ListenerOpt{vc.IdleTimeout{idleTime}}
+ lopts = []stream.ListenerOpt{vc.IdleTimeout{Duration: idleTime}}
} else {
- opts = []stream.VCOpt{vc.IdleTimeout{idleTime}}
+ opts = []stream.VCOpt{vc.IdleTimeout{Duration: idleTime}}
}
cctx, _ := v23.WithPrincipal(ctx, pclient)
sctx, _ := v23.WithPrincipal(ctx, pserver)
diff --git a/runtime/internal/rpc/stream/vif/vif.go b/runtime/internal/rpc/stream/vif/vif.go
index d1b1b92..86facf0 100644
--- a/runtime/internal/rpc/stream/vif/vif.go
+++ b/runtime/internal/rpc/stream/vif/vif.go
@@ -360,7 +360,7 @@
Versions: iversion.Range{Min: preauth.Version, Max: preauth.Version},
Options: []message.SetupOption{
&message.NaclBox{PublicKey: *pubKey},
- &message.UseVIFAuthentication{sigPreauth},
+ &message.UseVIFAuthentication{Signature: sigPreauth},
},
},
})
diff --git a/runtime/internal/rpc/stream/vif/vif_test.go b/runtime/internal/rpc/stream/vif/vif_test.go
index 908a711..a67b396 100644
--- a/runtime/internal/rpc/stream/vif/vif_test.go
+++ b/runtime/internal/rpc/stream/vif/vif_test.go
@@ -440,7 +440,11 @@
vfStartTime, remoteStartTime = remoteStartTime, vfStartTime
}
var err error
- vf, remote, err = New(nil, nil, cctx, sctx, notifyFunc, notifyFunc, []stream.VCOpt{vc.StartTimeout{vfStartTime}}, []stream.ListenerOpt{vc.StartTimeout{remoteStartTime}})
+ vf, remote, err = New(nil, nil, cctx, sctx, notifyFunc, notifyFunc, []stream.VCOpt{vc.StartTimeout{
+ Duration: vfStartTime,
+ }}, []stream.ListenerOpt{vc.StartTimeout{
+ Duration: remoteStartTime,
+ }})
if err != nil {
t.Fatal(err)
}
@@ -510,7 +514,7 @@
newVC := func(vf, remote *vif.VIF) (VC stream.VC, ln stream.Listener, remoteVC stream.Connector, triggerTimers func()) {
triggerTimers = vif.SetFakeTimers()
var err error
- VC, remoteVC, err = createVC(cctx, vf, remote, makeEP(0x10), vc.IdleTimeout{idleTime})
+ VC, remoteVC, err = createVC(cctx, vf, remote, makeEP(0x10), vc.IdleTimeout{Duration: idleTime})
if err != nil {
t.Fatal(err)
}
@@ -539,7 +543,7 @@
// Same as above, but with multiple VCs.
vf, remote = newVIF()
triggerTimers = vif.SetFakeTimers()
- if _, _, err := createNVCs(cctx, vf, remote, 0x10, 5, vc.IdleTimeout{idleTime}); err != nil {
+ if _, _, err := createNVCs(cctx, vf, remote, 0x10, 5, vc.IdleTimeout{Duration: idleTime}); err != nil {
t.Fatal(err)
}
triggerTimers()
@@ -713,15 +717,15 @@
// that overlapping ranges work properly, but non-overlapping ranges generate
// errors.
func TestIncompatibleVersions(t *testing.T) {
- unknown := &iversion.Range{version.UnknownRPCVersion, version.UnknownRPCVersion}
+ unknown := &iversion.Range{Min: version.UnknownRPCVersion, Max: version.UnknownRPCVersion}
tests := []versionTestCase{
- {&iversion.Range{2, 2}, &iversion.Range{2, 2}, &iversion.Range{2, 2}, false, false},
- {&iversion.Range{2, 3}, &iversion.Range{3, 5}, &iversion.Range{3, 5}, false, false},
- {&iversion.Range{2, 3}, &iversion.Range{3, 5}, unknown, false, false},
+ {&iversion.Range{Min: 2, Max: 2}, &iversion.Range{Min: 2, Max: 2}, &iversion.Range{Min: 2, Max: 2}, false, false},
+ {&iversion.Range{Min: 2, Max: 3}, &iversion.Range{Min: 3, Max: 5}, &iversion.Range{Min: 3, Max: 5}, false, false},
+ {&iversion.Range{Min: 2, Max: 3}, &iversion.Range{Min: 3, Max: 5}, unknown, false, false},
// VIF error since there are no versions in common.
- {&iversion.Range{2, 3}, &iversion.Range{4, 5}, &iversion.Range{4, 5}, true, true},
- {&iversion.Range{2, 3}, &iversion.Range{4, 5}, unknown, true, true},
+ {&iversion.Range{Min: 2, Max: 3}, &iversion.Range{Min: 4, Max: 5}, &iversion.Range{Min: 4, Max: 5}, true, true},
+ {&iversion.Range{Min: 2, Max: 3}, &iversion.Range{Min: 4, Max: 5}, unknown, true, true},
}
for _, tc := range tests {
diff --git a/runtime/internal/rpc/test/client_test.go b/runtime/internal/rpc/test/client_test.go
index 69d70e9..dcc54ff 100644
--- a/runtime/internal/rpc/test/client_test.go
+++ b/runtime/internal/rpc/test/client_test.go
@@ -279,8 +279,8 @@
}
logErr("no context", err)
- p1 := options.ServerPublicKey{testutil.NewPrincipal().PublicKey()}
- p2 := options.ServerPublicKey{testutil.NewPrincipal().PublicKey()}
+ p1 := options.ServerPublicKey{PublicKey: testutil.NewPrincipal().PublicKey()}
+ p2 := options.ServerPublicKey{PublicKey: testutil.NewPrincipal().PublicKey()}
_, err = client.StartCall(ctx, "noname", "nomethod", nil, p1, p2)
if verror.ErrorID(err) != verror.ErrBadArg.ID {
t.Fatalf("wrong error: %s", err)
diff --git a/runtime/internal/rpc/test/glob_test.go b/runtime/internal/rpc/test/glob_test.go
index a60f0d4..d881b67 100644
--- a/runtime/internal/rpc/test/glob_test.go
+++ b/runtime/internal/rpc/test/glob_test.go
@@ -297,7 +297,7 @@
func (o *globObject) globLoop(call rpc.GlobServerCall, name string, g *glob.Glob, n *node) {
if g.Len() == 0 {
- call.SendStream().Send(naming.GlobReplyEntry{naming.MountEntry{Name: name}})
+ call.SendStream().Send(naming.GlobReplyEntry{Value: naming.MountEntry{Name: name}})
}
if g.Empty() {
return
@@ -318,7 +318,7 @@
sender := call.SendStream()
for child, _ := range o.n.children {
if m.Match(child) {
- sender.Send(naming.GlobChildrenReplyName{child})
+ sender.Send(naming.GlobChildrenReplyName{Value: child})
}
}
return nil
diff --git a/runtime/internal/rpc/test/proxy_test.go b/runtime/internal/rpc/test/proxy_test.go
index e7d365a..46c5078 100644
--- a/runtime/internal/rpc/test/proxy_test.go
+++ b/runtime/internal/rpc/test/proxy_test.go
@@ -335,7 +335,7 @@
// Additionally, any server authorizaton options must only apply to the end server
// and not the proxy.
const expected = `method:"Echo",suffix:"suffix",arg:"batman"`
- if result, err := makeCall(options.ServerPublicKey{serverKey}); result != expected || err != nil {
+ if result, err := makeCall(options.ServerPublicKey{PublicKey: serverKey}); result != expected || err != nil {
t.Fatalf("Got (%v, %v) want (%v, nil)", result, err, expected)
}
diff --git a/runtime/internal/rt/ipc_test.go b/runtime/internal/rt/ipc_test.go
index 29c8153..23d320b 100644
--- a/runtime/internal/rt/ipc_test.go
+++ b/runtime/internal/rt/ipc_test.go
@@ -172,7 +172,7 @@
p = v23.GetPrincipal(ctx)
b1 = mkBlessings(p.BlessSelf("dev.v.io/users/foo@bar.com/devices/phone/applications/app"))
b2 = mkBlessings(p.BlessSelf("otherblessing"))
- bopt = options.ServerBlessings{union(b1, b2)}
+ bopt = options.ServerBlessings{Blessings: union(b1, b2)}
tests = []struct {
opts []rpc.ServerOpt
diff --git a/runtime/internal/rt/mgmt.go b/runtime/internal/rt/mgmt.go
index 8893016..28c25cf 100644
--- a/runtime/internal/rt/mgmt.go
+++ b/runtime/internal/rt/mgmt.go
@@ -55,7 +55,7 @@
// Grab the blessing from our blessing store that the parent
// told us to use so they can talk to us.
serverBlessing := rt.GetPrincipal(ctx).BlessingStore().ForPeer(parentPeerPattern)
- serverOpts = append(serverOpts, options.ServerBlessings{serverBlessing})
+ serverOpts = append(serverOpts, options.ServerBlessings{Blessings: serverBlessing})
}
server, err := rt.NewServer(ctx, serverOpts...)
if err != nil {
diff --git a/runtime/internal/rt/mgmt_test.go b/runtime/internal/rt/mgmt_test.go
index 2c59c05..ad1f650 100644
--- a/runtime/internal/rt/mgmt_test.go
+++ b/runtime/internal/rt/mgmt_test.go
@@ -161,7 +161,7 @@
}
func checkProgress(t *testing.T, ch <-chan v23.Task, progress, goal int32) {
- if want, got := (v23.Task{progress, goal}), <-ch; !reflect.DeepEqual(want, got) {
+ if want, got := (v23.Task{Progress: progress, Goal: goal}), <-ch; !reflect.DeepEqual(want, got) {
t.Errorf("Unexpected progress: want %+v, got %+v", want, got)
}
}
diff --git a/runtime/internal/rt/security.go b/runtime/internal/rt/security.go
index 5e439b1..1b8d6cf 100644
--- a/runtime/internal/rt/security.go
+++ b/runtime/internal/rt/security.go
@@ -20,6 +20,7 @@
"v.io/x/ref/lib/mgmt"
vsecurity "v.io/x/ref/lib/security"
inaming "v.io/x/ref/runtime/internal/naming"
+ "v.io/x/ref/services/agent"
"v.io/x/ref/services/agent/agentlib"
)
@@ -48,6 +49,11 @@
return principal, nil, func() {}, nil
}
// Use credentials stored in the agent.
+ if principal, err := ipcAgent(); err != nil {
+ return nil, nil, nil, err
+ } else if principal != nil {
+ return principal, nil, func() { principal.Close() }, nil
+ }
if ep, _, err := agentEP(); err != nil {
return nil, nil, nil, err
} else if ep != nil {
@@ -98,6 +104,24 @@
return ifd, nil
}
+func ipcAgent() (agent.Principal, error) {
+ handle, err := exec.GetChildHandle()
+ if err != nil && verror.ErrorID(err) != exec.ErrNoVersion.ID {
+ return nil, err
+ }
+ var path string
+ if handle != nil {
+ // We were started by a parent (presumably, device manager).
+ path, _ = handle.Config.Get(mgmt.SecurityAgentPathConfigKey)
+ } else {
+ path = os.Getenv(ref.EnvAgentPath)
+ }
+ if path == "" {
+ return nil, nil
+ }
+ return agentlib.NewAgentPrincipalX(path)
+}
+
// agentEP returns an Endpoint to be used to communicate with
// the security agent if the current process has been configured to use the
// agent.
diff --git a/services/agent/agentlib/client.go b/services/agent/agentlib/client.go
index 3f6f82c..1d72439 100644
--- a/services/agent/agentlib/client.go
+++ b/services/agent/agentlib/client.go
@@ -8,9 +8,11 @@
import (
"fmt"
+ "io"
"net"
"os"
"strconv"
+ "sync"
"syscall"
"v.io/v23/context"
@@ -21,7 +23,9 @@
"v.io/v23/verror"
"v.io/v23/vtrace"
"v.io/x/ref/internal/logger"
+ "v.io/x/ref/services/agent"
"v.io/x/ref/services/agent/internal/cache"
+ "v.io/x/ref/services/agent/internal/ipc"
"v.io/x/ref/services/agent/internal/unixfd"
)
@@ -38,13 +42,50 @@
key security.PublicKey
}
-type caller struct {
+type caller interface {
+ call(name string, results []interface{}, args ...interface{}) error
+ io.Closer
+}
+
+type ipcCaller struct {
+ conn *ipc.IPCConn
+ flush func()
+ mu sync.Mutex
+}
+
+func (i *ipcCaller) call(name string, results []interface{}, args ...interface{}) error {
+ return i.conn.Call(name, args, results...)
+}
+
+func (i *ipcCaller) Close() error {
+ i.conn.Close()
+ return nil
+}
+
+func (i *ipcCaller) FlushAllCaches() error {
+ var flush func()
+ i.mu.Lock()
+ flush = i.flush
+ i.mu.Unlock()
+ if flush != nil {
+ flush()
+ }
+ return nil
+}
+
+type vrpcCaller struct {
ctx *context.T
client rpc.Client
name string
+ cancel func()
}
-func (c *caller) call(name string, results []interface{}, args ...interface{}) error {
+func (c *vrpcCaller) Close() error {
+ c.cancel()
+ return nil
+}
+
+func (c *vrpcCaller) call(name string, results []interface{}, args ...interface{}) error {
call, err := c.startCall(name, args...)
if err != nil {
return err
@@ -55,7 +96,7 @@
return nil
}
-func (c *caller) startCall(name string, args ...interface{}) (rpc.ClientCall, error) {
+func (c *vrpcCaller) startCall(name string, args ...interface{}) (rpc.ClientCall, error) {
ctx, _ := vtrace.WithNewTrace(c.ctx)
// SecurityNone is safe here since we're using anonymous unix sockets.
return c.client.StartCall(ctx, c.name, name, args, options.SecurityNone, options.NoResolve{})
@@ -65,6 +106,41 @@
return inputs
}
+func newUncachedPrincipalX(path string) (*client, error) {
+ caller := new(ipcCaller)
+ i := ipc.NewIPC()
+ i.Serve(caller)
+ conn, err := i.Connect(path)
+ if err != nil {
+ return nil, err
+ }
+ caller.conn = conn
+ agent := &client{caller: caller}
+ if err := agent.fetchPublicKey(); err != nil {
+ return nil, err
+ }
+ return agent, nil
+}
+
+// NewAgentPrincipal returns a security.Pricipal using the PrivateKey held in a remote agent process.
+// 'path' is the path to the agent socket, typically obtained from
+// os.GetEnv(envvar.AgentAddress).
+func NewAgentPrincipalX(path string) (agent.Principal, error) {
+ p, err := newUncachedPrincipalX(path)
+ if err != nil {
+ return nil, err
+ }
+ cached, flush, err := cache.NewCachedPrincipalX(p)
+ if err != nil {
+ return nil, err
+ }
+ caller := p.caller.(*ipcCaller)
+ caller.mu.Lock()
+ caller.flush = flush
+ caller.mu.Unlock()
+ return cached, nil
+}
+
// NewAgentPrincipal returns a security.Pricipal using the PrivateKey held in a remote agent process.
// 'endpoint' is the endpoint for connecting to the agent, typically obtained from
// os.GetEnv(envvar.AgentEndpoint).
@@ -75,11 +151,12 @@
if err != nil {
return p, err
}
- call, callErr := p.caller.startCall("NotifyWhenChanged")
+ caller := p.caller.(*vrpcCaller)
+ call, callErr := caller.startCall("NotifyWhenChanged")
if callErr != nil {
return nil, callErr
}
- return cache.NewCachedPrincipal(p.caller.ctx, p, call)
+ return cache.NewCachedPrincipal(caller.ctx, p, call)
}
func newUncachedPrincipal(ctx *context.T, ep naming.Endpoint, insecureClient rpc.Client) (*client, error) {
// This isn't a real vanadium endpoint. It contains the vanadium version
@@ -112,10 +189,12 @@
if err != nil {
return nil, err
}
- caller := caller{
+ ctx, cancel := context.WithCancel(ctx)
+ caller := &vrpcCaller{
client: insecureClient,
name: naming.JoinAddressName(agentEndpoint("unixfd", addr.String()), ""),
ctx: ctx,
+ cancel: cancel,
}
agent := &client{caller: caller}
if err := agent.fetchPublicKey(); err != nil {
@@ -124,6 +203,10 @@
return agent, nil
}
+func (c *client) Close() error {
+ return c.caller.Close()
+}
+
func (c *client) fetchPublicKey() (err error) {
var b []byte
if err = c.caller.call("PublicKey", results(&b)); err != nil {
diff --git a/services/agent/agentlib/peer_test.go b/services/agent/agentlib/peer_test.go
index 99a86a1..3d5ceeb 100644
--- a/services/agent/agentlib/peer_test.go
+++ b/services/agent/agentlib/peer_test.go
@@ -14,3 +14,7 @@
func NewUncachedPrincipal(ctx *context.T, endpoint naming.Endpoint, insecureClient rpc.Client) (security.Principal, error) {
return newUncachedPrincipal(ctx, endpoint, insecureClient)
}
+
+func NewUncachedPrincipalX(path string) (security.Principal, error) {
+ return newUncachedPrincipalX(path)
+}
diff --git a/services/agent/internal/cache/cache.go b/services/agent/internal/cache/cache.go
index 29a518c..f4500a8 100644
--- a/services/agent/internal/cache/cache.go
+++ b/services/agent/internal/cache/cache.go
@@ -12,6 +12,8 @@
"v.io/v23/rpc"
"v.io/v23/security"
"v.io/v23/verror"
+ "v.io/x/ref/internal/logger"
+ "v.io/x/ref/services/agent"
"v.io/x/ref/services/agent/internal/lru"
)
@@ -30,7 +32,6 @@
type cachedRoots struct {
mu *sync.RWMutex
impl security.BlessingRoots
- ctx *context.T
cache map[string][]security.BlessingPattern // GUARDED_BY(mu)
// TODO(ataly): Get rid of the following fields once all agents have been
@@ -39,8 +40,8 @@
negative *lru.Cache // key + blessing -> error
}
-func newCachedRoots(ctx *context.T, impl security.BlessingRoots, mu *sync.RWMutex) (*cachedRoots, error) {
- roots := &cachedRoots{mu: mu, impl: impl, ctx: ctx}
+func newCachedRoots(impl security.BlessingRoots, mu *sync.RWMutex) (*cachedRoots, error) {
+ roots := &cachedRoots{mu: mu, impl: impl}
roots.flush()
if err := roots.fetchAndCacheRoots(); err != nil {
return nil, err
@@ -126,7 +127,7 @@
if !cacheExists {
r.mu.Lock()
if err := r.fetchAndCacheRoots(); err != nil {
- r.ctx.Errorf("failed to cache roots: %v", err)
+ logger.Global().Errorf("failed to cache roots: %v", err)
r.mu.Unlock()
return nil
}
@@ -177,7 +178,7 @@
for keyStr, patterns := range r.cache {
key, err := security.UnmarshalPublicKey([]byte(keyStr))
if err != nil {
- r.ctx.Errorf("security.UnmarshalPublicKey(%v) returned error: %v", []byte(keyStr), err)
+ logger.Global().Errorf("security.UnmarshalPublicKey(%v) returned error: %v", []byte(keyStr), err)
return nil
}
for _, p := range patterns {
@@ -219,7 +220,6 @@
mu *sync.RWMutex
key security.PublicKey
def security.Blessings
- ctx *context.T
hasDef bool
peers map[security.BlessingPattern]security.Blessings
impl security.BlessingStore
@@ -266,7 +266,7 @@
if union, err := security.UnionOfBlessings(ret, b); err == nil {
ret = union
} else {
- s.ctx.Errorf("UnionOfBlessings(%v, %v) failed: %v, dropping the latter from BlessingStore.ForPeers(%v)", ret, b, err, peerBlessings)
+ logger.Global().Errorf("UnionOfBlessings(%v, %v) failed: %v, dropping the latter from BlessingStore.ForPeers(%v)", ret, b, err, peerBlessings)
}
}
}
@@ -341,7 +341,7 @@
// wraps over another implementation and adds caching.
type cachedPrincipal struct {
cache security.Principal
- /* impl */ security.Principal
+ /* impl */ agent.Principal
}
func (p *cachedPrincipal) BlessingsByName(pattern security.BlessingPattern) []security.Blessings {
@@ -364,6 +364,10 @@
return p.cache.AddToRoots(blessings)
}
+func (p *cachedPrincipal) Close() error {
+ return p.Principal.Close()
+}
+
type dummySigner struct {
key security.PublicKey
}
@@ -377,9 +381,32 @@
return s.key
}
-func NewCachedPrincipal(ctx *context.T, impl security.Principal, call rpc.ClientCall) (p security.Principal, err error) {
+func NewCachedPrincipal(ctx *context.T, impl agent.Principal, call rpc.ClientCall) (p agent.Principal, err error) {
+ p, flush, err := NewCachedPrincipalX(impl)
+
+ if err == nil {
+ go func() {
+ var x bool
+ for {
+ if recvErr := call.Recv(&x); recvErr != nil {
+ if ctx.Err() != context.Canceled {
+ logger.Global().Errorf("Error from agent: %v", recvErr)
+ }
+ flush()
+ call.Finish()
+ return
+ }
+ flush()
+ }
+ }()
+ }
+
+ return
+}
+
+func NewCachedPrincipalX(impl agent.Principal) (p agent.Principal, flush func(), err error) {
var mu sync.RWMutex
- cachedRoots, err := newCachedRoots(ctx, impl.Roots(), &mu)
+ cachedRoots, err := newCachedRoots(impl.Roots(), &mu)
if err != nil {
return
}
@@ -387,34 +414,19 @@
mu: &mu,
key: impl.PublicKey(),
impl: impl.BlessingStore(),
- ctx: ctx,
}
- flush := func() {
+ flush = func() {
defer mu.Unlock()
mu.Lock()
cachedRoots.flush()
cachedStore.flush()
}
- p, err = security.CreatePrincipal(dummySigner{impl.PublicKey()}, cachedStore, cachedRoots)
+ sp, err := security.CreatePrincipal(dummySigner{impl.PublicKey()}, cachedStore, cachedRoots)
if err != nil {
return
}
- go func() {
- var x bool
- for {
- if recvErr := call.Recv(&x); recvErr != nil {
- if ctx.Err() != context.Canceled {
- ctx.Errorf("Error from agent: %v", recvErr)
- }
- flush()
- call.Finish()
- return
- }
- flush()
- }
- }()
- p = &cachedPrincipal{p, impl}
+ p = &cachedPrincipal{sp, impl}
return
}
diff --git a/services/agent/internal/cache/cache_test.go b/services/agent/internal/cache/cache_test.go
index b6b53d3..e0c2193 100644
--- a/services/agent/internal/cache/cache_test.go
+++ b/services/agent/internal/cache/cache_test.go
@@ -22,7 +22,7 @@
ctx = context.WithLogger(ctx, logger.Global())
p := testutil.NewPrincipal()
impl := p.Roots()
- roots, err := newCachedRoots(ctx, impl, &mu)
+ roots, err := newCachedRoots(impl, &mu)
if err != nil {
panic(err)
}
diff --git a/services/agent/internal/ipc/ipc.go b/services/agent/internal/ipc/ipc.go
index 000d716..ca1bd9d 100644
--- a/services/agent/internal/ipc/ipc.go
+++ b/services/agent/internal/ipc/ipc.go
@@ -291,7 +291,7 @@
func (ipc *IPC) startCall(c *IPCConn, method string, args []interface{}, results []interface{}) (ch chan error) {
ch = make(chan error, 1)
- header := agent.RpcMessageReq{agent.RpcRequest{Method: method, NumArgs: uint32(len(args))}}
+ header := agent.RpcMessageReq{Value: agent.RpcRequest{Method: method, NumArgs: uint32(len(args))}}
shouldClose := false
defer func() {
// Only close c after we unlock it.
diff --git a/services/agent/internal/ipc/ipc_test.go b/services/agent/internal/ipc/ipc_test.go
index 4c553eb..39d3ba0 100644
--- a/services/agent/internal/ipc/ipc_test.go
+++ b/services/agent/internal/ipc/ipc_test.go
@@ -123,7 +123,7 @@
t.Fatal(err)
}
- if err = enc.Encode(agent.RpcMessageReq{agent.RpcRequest{Id: 0, Method: "foo", NumArgs: 0}}); err != nil {
+ if err = enc.Encode(agent.RpcMessageReq{Value: agent.RpcRequest{Id: 0, Method: "foo", NumArgs: 0}}); err != nil {
t.Fatal(err)
}
var response agent.RpcMessage
@@ -153,7 +153,7 @@
t.Fatal(err)
}
- if err = enc.Encode(agent.RpcMessageReq{agent.RpcRequest{Id: 0, Method: "foo", NumArgs: 0}}); err != nil {
+ if err = enc.Encode(agent.RpcMessageReq{Value: agent.RpcRequest{Id: 0, Method: "foo", NumArgs: 0}}); err != nil {
if err != io.EOF {
t.Fatal(err)
}
@@ -185,7 +185,7 @@
t.Fatal(err)
}
- if err = enc.Encode(agent.RpcMessageReq{agent.RpcRequest{Id: 0, Method: "foo", NumArgs: 0}}); err != nil {
+ if err = enc.Encode(agent.RpcMessageReq{Value: agent.RpcRequest{Id: 0, Method: "foo", NumArgs: 0}}); err != nil {
if err != io.EOF {
t.Fatal(err)
}
diff --git a/services/agent/keymgr/client.go b/services/agent/keymgr/client.go
index 01098de..ae837dd 100644
--- a/services/agent/keymgr/client.go
+++ b/services/agent/keymgr/client.go
@@ -14,6 +14,8 @@
"v.io/v23/context"
"v.io/v23/verror"
+ "v.io/x/ref/services/agent"
+ "v.io/x/ref/services/agent/internal/ipc"
"v.io/x/ref/services/agent/internal/server"
"v.io/x/ref/services/agent/internal/unixfd"
)
@@ -30,6 +32,10 @@
const defaultManagerSocket = 4
+type KeyManager struct {
+ conn *ipc.IPCConn
+}
+
type Agent struct {
conn *net.UnixConn // Guarded by mu
mu sync.Mutex
@@ -40,6 +46,17 @@
return newAgent(defaultManagerSocket)
}
+// NewKeyManager returns a client connected to the specified KeyManager.
+func NewKeyManager(path string) (agent.KeyManager, error) {
+ i := ipc.NewIPC()
+ conn, err := i.Connect(path)
+ var m *KeyManager
+ if err == nil {
+ m = &KeyManager{conn}
+ }
+ return m, err
+}
+
func NewLocalAgent(ctx *context.T, path string, passphrase []byte) (*Agent, error) {
file, err := server.RunKeyManager(ctx, path, passphrase)
if err != nil {
@@ -79,19 +96,27 @@
if err != nil {
return nil, nil, err
}
- buf := make([]byte, server.PrincipalHandleByteSize)
+ buf := make([]byte, agent.PrincipalHandleByteSize)
n, err := a.conn.Read(buf)
if err != nil {
conn.Close()
return nil, nil, err
}
- if n != server.PrincipalHandleByteSize {
+ if n != agent.PrincipalHandleByteSize {
conn.Close()
- return nil, nil, verror.New(errInvalidResponse, ctx, server.PrincipalHandleByteSize, n)
+ return nil, nil, verror.New(errInvalidResponse, ctx, agent.PrincipalHandleByteSize, n)
}
return buf, conn, nil
}
+// NewPrincipal creates a new principal and returns a handle.
+// The handle may be passed to ServePrincipal to start an agent serving the principal.
+func (m *KeyManager) NewPrincipal(inMemory bool) (handle [agent.PrincipalHandleByteSize]byte, err error) {
+ args := []interface{}{inMemory}
+ err = m.conn.Call("NewPrincipal", args, &handle)
+ return
+}
+
func (a *Agent) connect(req []byte) (*os.File, error) {
addr, err := unixfd.SendConnection(a.conn, req)
if err != nil {
@@ -108,10 +133,37 @@
// previously created with NewPrincipal.
// Typically this will be passed to a child process using cmd.ExtraFiles.
func (a *Agent) NewConnection(handle []byte) (*os.File, error) {
- if len(handle) != server.PrincipalHandleByteSize {
+ if len(handle) != agent.PrincipalHandleByteSize {
return nil, verror.New(errInvalidKeyHandle, nil)
}
a.mu.Lock()
defer a.mu.Unlock()
return a.connect(handle)
}
+
+// ServePrincipal creates a socket at socketPath and serves a principal
+// previously created with NewPrincipal.
+func (m *KeyManager) ServePrincipal(handle [agent.PrincipalHandleByteSize]byte, socketPath string) error {
+ args := []interface{}{handle, socketPath}
+ return m.conn.Call("ServePrincipal", args)
+}
+
+// StopServing shuts down a server previously started with ServePrincipal.
+// The principal is not deleted and the server can be restarted by calling
+// ServePrincipal again.
+func (m *KeyManager) StopServing(handle [agent.PrincipalHandleByteSize]byte) error {
+ args := []interface{}{handle}
+ return m.conn.Call("StopServing", args)
+}
+
+// DeletePrincipal shuts down a server started by ServePrincipal and additionally
+// deletes the principal.
+func (m *KeyManager) DeletePrincipal(handle [agent.PrincipalHandleByteSize]byte) error {
+ args := []interface{}{handle}
+ return m.conn.Call("DeletePrincipal", args)
+}
+
+func (m *KeyManager) Close() error {
+ m.conn.Close()
+ return nil
+}
diff --git a/services/agent/model.go b/services/agent/model.go
new file mode 100644
index 0000000..38d6ece
--- /dev/null
+++ b/services/agent/model.go
@@ -0,0 +1,27 @@
+// 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 agent
+
+import (
+ "crypto/sha512"
+ "io"
+
+ "v.io/v23/security"
+)
+
+type Principal interface {
+ security.Principal
+ io.Closer
+}
+
+const PrincipalHandleByteSize = sha512.Size
+
+type KeyManager interface {
+ NewPrincipal(inMemory bool) (handle [PrincipalHandleByteSize]byte, err error)
+ ServePrincipal(handle [PrincipalHandleByteSize]byte, socketPath string) error
+ StopServing(handle [PrincipalHandleByteSize]byte) error
+ DeletePrincipal(handle [PrincipalHandleByteSize]byte) error
+ io.Closer
+}
diff --git a/services/application/applicationd/service.go b/services/application/applicationd/service.go
index c4e833e..2ea8bff 100644
--- a/services/application/applicationd/service.go
+++ b/services/application/applicationd/service.go
@@ -249,7 +249,7 @@
for _, r := range results {
if m.Match(r) {
- call.SendStream().Send(naming.GlobChildrenReplyName{r})
+ call.SendStream().Send(naming.GlobChildrenReplyName{Value: r})
}
}
return nil
diff --git a/services/binary/tidy/binaryd/mock.go b/services/binary/tidy/binaryd/mock.go
index a9c1db0..d3efd8c 100644
--- a/services/binary/tidy/binaryd/mock.go
+++ b/services/binary/tidy/binaryd/mock.go
@@ -74,7 +74,7 @@
gs := GlobStimulus{g.String()}
gr := mdi.Tape.Record(gs).(GlobResponse)
for _, r := range gr.Results {
- call.SendStream().Send(naming.GlobReplyEntry{naming.MountEntry{Name: r}})
+ call.SendStream().Send(naming.GlobReplyEntry{Value: naming.MountEntry{Name: r}})
}
return gr.Err
}
diff --git a/services/device/device/claim.go b/services/device/device/claim.go
index 8d65e4d..2fb911c 100644
--- a/services/device/device/claim.go
+++ b/services/device/device/claim.go
@@ -54,7 +54,7 @@
if deviceKey, err := security.UnmarshalPublicKey(marshalledPublicKey); err != nil {
return fmt.Errorf("Failed to unmarshal device public key:%v", err)
} else {
- serverKeyOpts = options.ServerPublicKey{deviceKey}
+ serverKeyOpts = options.ServerPublicKey{PublicKey: deviceKey}
}
}
// Skip server endpoint authorization since an unclaimed device might have
diff --git a/services/device/device/devicemanager_mock_test.go b/services/device/device/devicemanager_mock_test.go
index 6d1e486..4ca86c9 100644
--- a/services/device/device/devicemanager_mock_test.go
+++ b/services/device/device/devicemanager_mock_test.go
@@ -296,7 +296,7 @@
gs := GlobStimulus{g.String()}
gr := mdi.tape.Record(gs).(GlobResponse)
for _, r := range gr.results {
- call.SendStream().Send(naming.GlobReplyEntry{naming.MountEntry{Name: r}})
+ call.SendStream().Send(naming.GlobReplyEntry{Value: naming.MountEntry{Name: r}})
}
return gr.err
}
diff --git a/services/device/device/instantiate.go b/services/device/device/instantiate.go
index 8d8ab2c..f6c7b76 100644
--- a/services/device/device/instantiate.go
+++ b/services/device/device/instantiate.go
@@ -67,7 +67,7 @@
if err != nil {
return fmt.Errorf("Instantiate failed: %v", err)
}
- call.SendStream().Send(device.BlessClientMessageAppBlessings{blessings})
+ call.SendStream().Send(device.BlessClientMessageAppBlessings{Value: blessings})
default:
fmt.Fprintf(env.Stderr, "Received unexpected message: %#v\n", msg)
}
diff --git a/services/device/deviced/internal/impl/app_service.go b/services/device/deviced/internal/impl/app_service.go
index 576ffa3..77896fe 100644
--- a/services/device/deviced/internal/impl/app_service.go
+++ b/services/device/deviced/internal/impl/app_service.go
@@ -1455,7 +1455,7 @@
}
for child, _ := range n.children {
if m.Match(child) {
- call.SendStream().Send(naming.GlobChildrenReplyName{child})
+ call.SendStream().Send(naming.GlobChildrenReplyName{Value: child})
}
}
return nil
diff --git a/services/device/deviced/internal/impl/device_service.go b/services/device/deviced/internal/impl/device_service.go
index 480b8aa..055af58 100644
--- a/services/device/deviced/internal/impl/device_service.go
+++ b/services/device/deviced/internal/impl/device_service.go
@@ -326,7 +326,7 @@
cfg.Set(mgmt.SecurityAgentEndpointConfigKey, ep)
}
- handle := vexec.NewParentHandle(cmd, vexec.ConfigOpt{cfg})
+ handle := vexec.NewParentHandle(cmd, vexec.ConfigOpt{Config: cfg})
// Start the child process.
if err := handle.Start(); err != nil {
ctx.Errorf("Start() failed: %v", err)
diff --git a/services/device/deviced/internal/impl/proxy_invoker.go b/services/device/deviced/internal/impl/proxy_invoker.go
index c395de6..d15dec1 100644
--- a/services/device/deviced/internal/impl/proxy_invoker.go
+++ b/services/device/deviced/internal/impl/proxy_invoker.go
@@ -214,7 +214,7 @@
}
func (p *proxyInvoker) Globber() *rpc.GlobState {
- return &rpc.GlobState{AllGlobberX: p}
+ return &rpc.GlobState{AllGlobber: p}
}
type call struct {
diff --git a/services/device/deviced/internal/impl/utiltest/helpers.go b/services/device/deviced/internal/impl/utiltest/helpers.go
index cd61e3c..3c1a163 100644
--- a/services/device/deviced/internal/impl/utiltest/helpers.go
+++ b/services/device/deviced/internal/impl/utiltest/helpers.go
@@ -327,7 +327,7 @@
if err != nil {
return "", errors.New("bless failed")
}
- call.SendStream().Send(device.BlessClientMessageAppBlessings{blessings})
+ call.SendStream().Send(device.BlessClientMessageAppBlessings{Value: blessings})
default:
return "", fmt.Errorf("newInstanceImpl: received unexpected message: %#v", msg)
}
diff --git a/services/device/deviced/internal/impl/utiltest/modules.go b/services/device/deviced/internal/impl/utiltest/modules.go
index 2a5a029..3f42f83 100644
--- a/services/device/deviced/internal/impl/utiltest/modules.go
+++ b/services/device/deviced/internal/impl/utiltest/modules.go
@@ -92,13 +92,14 @@
// method that calls Stop on the app cycle manager (e.g. the Stop RPC)
// will precipitate an immediate process exit.
shutdownChan := signals.ShutdownOnSignals(ctx)
+ localhost := []struct{ Protocol, Address string }{{"tcp", "127.0.0.1:0"}}
claimableName, stop, err := starter.Start(ctx, starter.Args{
Namespace: starter.NamespaceArgs{
- ListenSpec: rpc.ListenSpec{Addrs: rpc.ListenAddrs{{"tcp", "127.0.0.1:0"}}},
+ ListenSpec: rpc.ListenSpec{Addrs: rpc.ListenAddrs(localhost)},
},
Device: starter.DeviceArgs{
Name: publishName,
- ListenSpec: rpc.ListenSpec{Addrs: rpc.ListenAddrs{{"tcp", "127.0.0.1:0"}}},
+ ListenSpec: rpc.ListenSpec{Addrs: rpc.ListenAddrs(localhost)},
ConfigState: configState,
TestMode: strings.HasSuffix(fmt.Sprint(v23.GetPrincipal(ctx).BlessingStore().Default()), "/testdm"),
RestartCallback: func() { fmt.Println("restart handler") },
diff --git a/services/internal/binarylib/service.go b/services/internal/binarylib/service.go
index 99b25ad..3a43e42 100644
--- a/services/internal/binarylib/service.go
+++ b/services/internal/binarylib/service.go
@@ -391,7 +391,7 @@
}
for k, _ := range n.children {
if m.Match(k) {
- call.SendStream().Send(naming.GlobChildrenReplyName{k})
+ call.SendStream().Send(naming.GlobChildrenReplyName{Value: k})
}
}
return nil
diff --git a/services/internal/logreaderlib/logfile.go b/services/internal/logreaderlib/logfile.go
index 5a4109d..5654301 100644
--- a/services/internal/logreaderlib/logfile.go
+++ b/services/internal/logreaderlib/logfile.go
@@ -149,7 +149,7 @@
for _, file := range fi {
name := file.Name()
if m.Match(name) {
- call.SendStream().Send(naming.GlobChildrenReplyName{name})
+ call.SendStream().Send(naming.GlobChildrenReplyName{Value: name})
}
}
}
diff --git a/services/internal/statslib/stats.go b/services/internal/statslib/stats.go
index ddc2735..08f7157 100644
--- a/services/internal/statslib/stats.go
+++ b/services/internal/statslib/stats.go
@@ -44,7 +44,7 @@
sender := call.SendStream()
it := libstats.Glob(i.suffix, g.String(), time.Time{}, false)
for it.Advance() {
- sender.Send(naming.GlobReplyEntry{naming.MountEntry{Name: it.Value().Key}})
+ sender.Send(naming.GlobReplyEntry{Value: naming.MountEntry{Name: it.Value().Key}})
}
if err := it.Err(); err != nil {
ctx.VI(1).Infof("libstats.Glob(%q, %q) failed: %v", i.suffix, g.String(), err)
diff --git a/services/mounttable/mounttablelib/mounttable.go b/services/mounttable/mounttablelib/mounttable.go
index d1c7258..52e3e96 100644
--- a/services/mounttable/mounttablelib/mounttable.go
+++ b/services/mounttable/mounttablelib/mounttable.go
@@ -682,7 +682,7 @@
}
// Hold no locks while we are sending on the channel to avoid livelock.
n.Unlock()
- gCall.SendStream().Send(naming.GlobReplyEntry{me})
+ gCall.SendStream().Send(naming.GlobReplyEntry{Value: me})
return
}
@@ -752,7 +752,7 @@
// Hold no locks while we are sending on the channel to avoid livelock.
n.Unlock()
// Intermediate nodes are marked as serving a mounttable since they answer the mounttable methods.
- gCall.SendStream().Send(naming.GlobReplyEntry{naming.MountEntry{Name: name, ServesMountTable: true}})
+ gCall.SendStream().Send(naming.GlobReplyEntry{Value: naming.MountEntry{Name: name, ServesMountTable: true}})
}
// Glob finds matches in the namespace. If we reach a mount point before matching the
@@ -798,7 +798,7 @@
servers[i].Server = naming.Join(s.Server, strings.Join(elems, "/"))
}
n.Unlock()
- gCall.SendStream().Send(naming.GlobReplyEntry{naming.MountEntry{Name: "", Servers: servers}})
+ gCall.SendStream().Send(naming.GlobReplyEntry{Value: naming.MountEntry{Name: "", Servers: servers}})
}
func (ms *mountContext) SetPermissions(ctx *context.T, call rpc.ServerCall, perms access.Permissions, version string) error {
diff --git a/services/mounttable/mounttablelib/mounttable_test.go b/services/mounttable/mounttablelib/mounttable_test.go
index 879943b..002af2b 100644
--- a/services/mounttable/mounttablelib/mounttable_test.go
+++ b/services/mounttable/mounttablelib/mounttable_test.go
@@ -484,7 +484,7 @@
root, _, _ := mt.Lookup(ctx, "")
g, _ := glob.Parse("...")
fCall := &fakeServerCall{}
- root.(rpc.Globber).Globber().AllGlobberX.Glob__(ctx, fCall, g)
+ root.(rpc.Globber).Globber().AllGlobber.Glob__(ctx, fCall, g)
return fCall.sendCount, nil
}
diff --git a/services/mounttable/mounttablelib/neighborhood.go b/services/mounttable/mounttablelib/neighborhood.go
index 20997cf..c0cc83b 100644
--- a/services/mounttable/mounttablelib/neighborhood.go
+++ b/services/mounttable/mounttablelib/neighborhood.go
@@ -207,11 +207,14 @@
}
addr := s[len(addressPrefix):]
ttl := time.Second * time.Duration(rr.Header().Ttl)
- addrMap[addr] = vdltime.Deadline{now.Add(ttl)}
+ addrMap[addr] = vdltime.Deadline{Time: now.Add(ttl)}
}
}
for addr, deadline := range addrMap {
- reply = append(reply, naming.MountedServer{addr, deadline})
+ reply = append(reply, naming.MountedServer{
+ Server: addr,
+ Deadline: deadline,
+ })
}
return reply
}
@@ -284,7 +287,7 @@
matcher := g.Head()
for k, n := range nh.neighbors() {
if matcher.Match(k) {
- sender.Send(naming.GlobReplyEntry{naming.MountEntry{Name: k, Servers: n, ServesMountTable: true}})
+ sender.Send(naming.GlobReplyEntry{Value: naming.MountEntry{Name: k, Servers: n, ServesMountTable: true}})
}
}
return nil
@@ -293,7 +296,7 @@
if neighbor == nil {
return verror.New(naming.ErrNoSuchName, ctx, ns.elems[0])
}
- sender.Send(naming.GlobReplyEntry{naming.MountEntry{Name: "", Servers: neighbor, ServesMountTable: true}})
+ sender.Send(naming.GlobReplyEntry{Value: naming.MountEntry{Name: "", Servers: neighbor, ServesMountTable: true}})
return nil
default:
return verror.New(naming.ErrNoSuchName, ctx, ns.elems)
diff --git a/services/mounttable/mounttablelib/serverlist.go b/services/mounttable/mounttablelib/serverlist.go
index 65f1061..d5b8084 100644
--- a/services/mounttable/mounttablelib/serverlist.go
+++ b/services/mounttable/mounttablelib/serverlist.go
@@ -120,7 +120,7 @@
s := e.Value.(*server)
ms := naming.MountedServer{
Server: s.oa,
- Deadline: vdltime.Deadline{s.expires},
+ Deadline: vdltime.Deadline{Time: s.expires},
}
slice = append(slice, ms)
}
diff --git a/services/mounttable/mounttablelib/serverlist_test.go b/services/mounttable/mounttablelib/serverlist_test.go
index c061f00..3f8c56a 100644
--- a/services/mounttable/mounttablelib/serverlist_test.go
+++ b/services/mounttable/mounttablelib/serverlist_test.go
@@ -48,7 +48,7 @@
if got, want := sl.copyToSlice(), []naming.MountedServer{
{
Server: "endpoint:dfgsfdg@@",
- Deadline: vdltime.Deadline{now.Add(15 * time.Second)},
+ Deadline: vdltime.Deadline{Time: now.Add(15 * time.Second)},
},
}; !reflect.DeepEqual(got, want) {
t.Errorf("Got %v, want %v", got, want)
diff --git a/services/role/roled/internal/glob.go b/services/role/roled/internal/glob.go
index 88b0478..12735e0 100644
--- a/services/role/roled/internal/glob.go
+++ b/services/role/roled/internal/glob.go
@@ -29,7 +29,7 @@
}
for c := range n.children {
if m.Match(c) {
- call.SendStream().Send(naming.GlobChildrenReplyName{c})
+ call.SendStream().Send(naming.GlobChildrenReplyName{Value: c})
}
}
return nil
diff --git a/services/role/roled/internal/role.go b/services/role/roled/internal/role.go
index 5e4aadc..5f4c733 100644
--- a/services/role/roled/internal/role.go
+++ b/services/role/roled/internal/role.go
@@ -129,7 +129,11 @@
if err != nil {
return security.Blessings{}, verror.Convert(verror.ErrInternal, ctx, err)
}
- thirdParty, err := security.NewPublicKeyCaveat(principal.PublicKey(), dischargerLocation, security.ThirdPartyRequirements{true, true, true}, loggingCaveat)
+ thirdParty, err := security.NewPublicKeyCaveat(principal.PublicKey(), dischargerLocation, security.ThirdPartyRequirements{
+ ReportServer: true,
+ ReportMethod: true,
+ ReportArguments: true,
+ }, loggingCaveat)
if err != nil {
return security.Blessings{}, verror.Convert(verror.ErrInternal, ctx, err)
}
diff --git a/services/wspr/internal/principal/principal_test.go b/services/wspr/internal/principal/principal_test.go
index 189c052..64cb612 100644
--- a/services/wspr/internal/principal/principal_test.go
+++ b/services/wspr/internal/principal/principal_test.go
@@ -178,12 +178,18 @@
if err != nil {
t.Fatalf("NewPrincipalManager failed: %v", err)
}
+
googleAccount := "fred/jim@gmail.com"
+ googleBlessings := accountBlessing(root, googleAccount)
+
+ if err := m.AddAccount(googleAccount, googleBlessings); err != nil {
+ t.Errorf("AddAccount(%v, %v) failed: %v", googleAccount, googleBlessings, err)
+ }
// Test with unknown origin.
unknownOrigin := "http://unknown.com"
if m.OriginHasAccount(unknownOrigin) {
- fmt.Errorf("Expected m.OriginHasAccount(%v) to be false but it was true.", unknownOrigin)
+ t.Errorf("Expected m.OriginHasAccount(%v) to be false but it was true.", unknownOrigin)
}
// Test with no expiration caveat.
@@ -191,15 +197,15 @@
methodCav, err := security.NewMethodCaveat("Foo")
if err != nil {
- fmt.Errorf("security.MethodCaveat failed: %v", err)
+ t.Errorf("security.MethodCaveat failed: %v", err)
}
if err := m.AddOrigin(origin1, googleAccount, []security.Caveat{methodCav}, nil); err != nil {
- fmt.Errorf("AddOrigin failed: %v", err)
+ t.Errorf("AddOrigin failed: %v", err)
}
if !m.OriginHasAccount(origin1) {
- fmt.Errorf("Expected m.OriginHasAccount(%v) to be true but it was false.", origin1)
+ t.Errorf("Expected m.OriginHasAccount(%v) to be true but it was false.", origin1)
}
// Test with expiration caveat in the future.
@@ -208,15 +214,15 @@
futureExpCav, err := security.NewExpiryCaveat(futureTime)
if err != nil {
- fmt.Errorf("security.NewExpiryCaveat(%v) failed: %v", futureTime, err)
+ t.Errorf("security.NewExpiryCaveat(%v) failed: %v", futureTime, err)
}
if err := m.AddOrigin(origin2, googleAccount, []security.Caveat{futureExpCav}, []time.Time{futureTime}); err != nil {
- fmt.Errorf("AddOrigin failed: %v", err)
+ t.Errorf("AddOrigin failed: %v", err)
}
if !m.OriginHasAccount(origin2) {
- fmt.Errorf("Expected m.OriginHasAccount(%v) to be true but it was false.", origin2)
+ t.Errorf("Expected m.OriginHasAccount(%v) to be true but it was false.", origin2)
}
// Test with expiration caveats in the past and future.
@@ -225,14 +231,14 @@
pastExpCav, err := security.NewExpiryCaveat(pastTime)
if err != nil {
- fmt.Errorf("security.NewExpiryCaveat(%v) failed: %v", pastTime, err)
+ t.Errorf("security.NewExpiryCaveat(%v) failed: %v", pastTime, err)
}
if err := m.AddOrigin(origin3, googleAccount, []security.Caveat{futureExpCav, pastExpCav}, []time.Time{futureTime, pastTime}); err != nil {
- fmt.Errorf("AddOrigin failed: %v", err)
+ t.Errorf("AddOrigin failed: %v", err)
}
if m.OriginHasAccount(origin3) {
- fmt.Errorf("Expected m.OriginHasAccount(%v) to be false but it was true.", origin3)
+ t.Errorf("Expected m.OriginHasAccount(%v) to be false but it was true.", origin3)
}
}
diff --git a/services/wspr/internal/rpc/server/invoker.go b/services/wspr/internal/rpc/server/invoker.go
index 9e6e40c..ae5c48a 100644
--- a/services/wspr/internal/rpc/server/invoker.go
+++ b/services/wspr/internal/rpc/server/invoker.go
@@ -84,7 +84,7 @@
if i.globFunc == nil {
return nil
}
- return &rpc.GlobState{AllGlobberX: i}
+ return &rpc.GlobState{AllGlobber: i}
}
func (i *invoker) Glob__(ctx *context.T, call rpc.GlobServerCall, g *glob.Glob) error {
