veyron2/{vdl,vom2,ipc}: Finish the vom2 transition.
This CL enables the vom2 transition; vom1 is still the default,
and vom2 is enabled by setting the VEYRON_VOM2 env var to any
non-empty string. All tests pass in both modes, except for 2
tests with trivial differences (nil vs. empty collections). Note
that vom2 uses the updated vdl type system semantics, thus the
difference.
Here are the changes:
o Add type registration to the vdl package, so that the various
security-related features that rely on it can work. I have a
TODO to add support for external types (e.g. Go time.Time),
and have thought through the strategy, and will do that later.
o Add vdl codegen for type names associated with every defined
type, and consolidate the different "__Describe" mechanisms
into a single __VDLDescribe. Associating the name as a
struct field tag allows us to capture it via reflection, and
avoids any weird registration; it's a property of the type.
o Add a simple transition mechanism for vom2; if you set the
VEYRON_VOM2 environment variable to any non-empty string,
we'll enable vom2 mode; all ipc will be over vom2.
o Fixed a bunch of bugs along the way, most due to bad handling
of optional types in value conversion, and with lots of help
from Asim debugging.
o Changed some apps / tests to use verror2. The issue is that
vdl / vom2 uses verror2 as its base error, and verror2
formats error messages slightly differently, with a prefix.
Tests that were string-matching on the error string would
break. It seemed better to just updated them to verror2,
although I was going to kill myself updating the node/impl
tests.
o Changed vdl / vom2 to use nil to represent empty slices /
maps in generated Go code. This is more idiomatic, and leads
to many fewer trivially failing tests.
Note that because of the vdl codegen changes, I'll need to
trivially re-generate the code in every repo; I'll send out
separate CLs for that after I get an OK for this one.
Change-Id: I3d6755b22d59e4087df9a723233af0c963d4a671
diff --git a/runtimes/google/ipc/client.go b/runtimes/google/ipc/client.go
index a246e1f..2788afb 100644
--- a/runtimes/google/ipc/client.go
+++ b/runtimes/google/ipc/client.go
@@ -27,6 +27,7 @@
verror "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
"veyron.io/veyron/veyron2/vom"
+ "veyron.io/veyron/veyron2/vom2"
"veyron.io/veyron/veyron2/vtrace"
)
@@ -52,6 +53,9 @@
errSystemRetry = verror.Register(pkgPath+".sysErrorRetryConnection", verror.RetryConnection, "{:3:}")
errSystemNoRetry = verror.Register(pkgPath+".sysErrorNoRetry", verror.NoRetry, "{:3:}")
+ errVomEncoder = verror.Register(pkgPath+".vomEncoder", verror.NoRetry, "failed to create vom encoder {:3}")
+ errVomDecoder = verror.Register(pkgPath+".vomDecoder", verror.NoRetry, "failed to create vom decoder {:3}")
+
errRequestEncoding = verror.Register(pkgPath+".requestEncoding", verror.NoRetry, "failed to encode request {3}{:4}")
errDischargeEncoding = verror.Register(pkgPath+".dischargeEncoding", verror.NoRetry, "failed to encode discharge {3}{:4}")
@@ -453,7 +457,10 @@
//
// We must ensure that all flows other than r.flow are closed.
go cleanupTryCall(r, responses, ch)
- fc := newFlowClient(ctx, serverB, r.flow, c.dc)
+ fc, err := newFlowClient(ctx, serverB, r.flow, c.dc)
+ if err != nil {
+ return nil, err.(verror.E)
+ }
if doneChan := ctx.Done(); doneChan != nil {
go func() {
@@ -596,8 +603,8 @@
// flow that's already connected to the server.
type flowClient struct {
ctx context.T // context to annotate with call details
- dec *vom.Decoder // to decode responses and results from the server
- enc *vom.Encoder // to encode requests and args to the server
+ dec vomDecoder // to decode responses and results from the server
+ enc vomEncoder // to encode requests and args to the server
server []string // Blessings bound to the server that authorize it to receive the IPC request from the client.
flow stream.Flow // the underlying flow
response ipc.Response // each decoded response message is kept here
@@ -614,8 +621,8 @@
var _ ipc.Call = (*flowClient)(nil)
var _ ipc.Stream = (*flowClient)(nil)
-func newFlowClient(ctx context.T, server []string, flow stream.Flow, dc vc.DischargeClient) *flowClient {
- return &flowClient{
+func newFlowClient(ctx context.T, server []string, flow stream.Flow, dc vc.DischargeClient) (*flowClient, error) {
+ fc := &flowClient{
ctx: ctx,
dec: vom.NewDecoder(flow),
enc: vom.NewEncoder(flow),
@@ -623,6 +630,19 @@
flow: flow,
dc: dc,
}
+ if vom2.IsEnabled() {
+ var err error
+ if fc.enc, err = vom2.NewBinaryEncoder(flow); err != nil {
+ return nil, fc.close(badProtocol(fc.ctx, verror.Make(errVomEncoder, fc.ctx, err)))
+ }
+ if fc.dec, err = vom2.NewDecoder(flow); err != nil {
+ return nil, fc.close(badProtocol(fc.ctx, verror.Make(errVomDecoder, fc.ctx, err)))
+ }
+ } else {
+ fc.dec = vom.NewDecoder(flow)
+ fc.enc = vom.NewEncoder(flow)
+ }
+ return fc, nil
}
func (fc *flowClient) close(verr verror.E) verror.E {
diff --git a/runtimes/google/ipc/flow_test.go b/runtimes/google/ipc/flow_test.go
deleted file mode 100644
index c44b050..0000000
--- a/runtimes/google/ipc/flow_test.go
+++ /dev/null
@@ -1,167 +0,0 @@
-package ipc
-
-import (
- "bytes"
- "errors"
- "fmt"
- "testing"
-
- "veyron.io/veyron/veyron/lib/testutil"
- tsecurity "veyron.io/veyron/veyron/lib/testutil/security"
-
- "veyron.io/veyron/veyron2/ipc"
- "veyron.io/veyron/veyron2/naming"
- "veyron.io/veyron/veyron2/security"
- "veyron.io/veyron/veyron2/verror"
-)
-
-func init() { testutil.Init() }
-
-// newTestFlows returns the two ends of a bidirectional flow. Each end has its
-// own bookkeeping, to allow testing of method calls.
-func newTestFlows() (*testFlow, *testFlow) {
- var (
- p0, p1 = tsecurity.NewPrincipal("p0"), tsecurity.NewPrincipal("p1")
- blessing0, blessing1 = p0.BlessingStore().Default(), p1.BlessingStore().Default()
- b0, b1 = new(bytes.Buffer), new(bytes.Buffer)
- )
- return &testFlow{r: b0, w: b1, p: p0, lb: blessing0, rb: blessing1}, &testFlow{r: b1, w: b0, p: p1, lb: blessing1, rb: blessing0}
-}
-
-type testFlow struct {
- r, w *bytes.Buffer
- p security.Principal
- lb, rb security.Blessings
- numCloseCalls int
- errClose error
-}
-
-func (f *testFlow) Read(b []byte) (int, error) { return f.r.Read(b) }
-func (f *testFlow) Write(b []byte) (int, error) { return f.w.Write(b) }
-func (*testFlow) LocalEndpoint() naming.Endpoint { return nil }
-func (*testFlow) RemoteEndpoint() naming.Endpoint { return nil }
-func (f *testFlow) LocalPrincipal() security.Principal { return f.p }
-func (f *testFlow) LocalBlessings() security.Blessings { return f.lb }
-func (f *testFlow) RemoteBlessings() security.Blessings { return f.rb }
-func (*testFlow) RemoteDischarges() map[string]security.Discharge { return nil }
-func (*testFlow) SetDeadline(<-chan struct{}) {}
-func (*testFlow) IsClosed() bool { return false }
-func (*testFlow) Closed() <-chan struct{} { return nil }
-func (*testFlow) Cancel() {}
-
-func (f *testFlow) Close() error {
- f.numCloseCalls++
- return f.errClose
-}
-
-// testDisp implements a simple test dispatcher, that uses the newInvoker
-// factory function to create an underlying invoker on each Lookup.
-type testDisp struct {
- newInvoker func(suffix string) ipc.Invoker
-}
-
-func (td testDisp) Lookup(suffix string) (interface{}, security.Authorizer, error) {
- return td.newInvoker(suffix), testServerAuthorizer{}, nil
-}
-
-// closureInvoker serves a method with no user args or results:
-// func(ipc.ServerCall) error
-type closureInvoker struct{ suffix string }
-
-func newClosureInvoker(suffix string) ipc.Invoker {
- return closureInvoker{suffix}
-}
-
-func (closureInvoker) Prepare(method string, numArgs int) (argptrs, tags []interface{}, err error) {
- return nil, nil, nil
-}
-func (inv closureInvoker) Invoke(method string, call ipc.ServerCall, argptrs []interface{}) (results []interface{}, err error) {
- if inv.suffix == "" {
- return nil, nil
- }
- return nil, errors.New(inv.suffix)
-}
-func (closureInvoker) Signature(ctx ipc.ServerContext) ([]ipc.InterfaceSig, error) {
- return nil, nil
-}
-func (closureInvoker) MethodSignature(ctx ipc.ServerContext, method string) (ipc.MethodSig, error) {
- return ipc.MethodSig{}, nil
-}
-func (closureInvoker) VGlob() *ipc.GlobState {
- return nil
-}
-
-// echoInvoker serves a method that takes a string and echoes it:
-// func(_ ServerCall, arg string) (string, error)
-type echoInvoker struct{ suffix string }
-
-func newEchoInvoker(suffix string) ipc.Invoker {
- return echoInvoker{suffix}
-}
-
-func (echoInvoker) Prepare(method string, numArgs int) (argptrs, tags []interface{}, err error) {
- var arg string
- return []interface{}{&arg}, nil, nil
-}
-func (inv echoInvoker) Invoke(method string, call ipc.ServerCall, argptrs []interface{}) (results []interface{}, err error) {
- result := fmt.Sprintf("method:%q,suffix:%q,arg:%q", method, inv.suffix, *argptrs[0].(*string))
- return []interface{}{result}, nil
-}
-func (echoInvoker) Signature(ctx ipc.ServerContext) ([]ipc.InterfaceSig, error) {
- return nil, nil
-}
-func (echoInvoker) MethodSignature(ctx ipc.ServerContext, method string) (ipc.MethodSig, error) {
- return ipc.MethodSig{}, nil
-}
-func (echoInvoker) VGlob() *ipc.GlobState {
- return nil
-}
-
-func TestFlowClientServer(t *testing.T) {
- type v []interface{}
- type testcase struct {
- suffix string
- method string
- args []interface{}
- expect []interface{}
- err error
- }
- tests := []testcase{
- {"echo", "A", v{""}, v{`method:"A",suffix:"echo",arg:""`}, nil},
- {"echo", "B", v{"foo"}, v{`method:"B",suffix:"echo",arg:"foo"`}, nil},
- {"echo/abc", "C", v{""}, v{`method:"C",suffix:"echo/abc",arg:""`}, nil},
- {"echo/abc", "D", v{"foo"}, v{`method:"D",suffix:"echo/abc",arg:"foo"`}, nil},
- }
- name := func(t testcase) string {
- return fmt.Sprintf("%s.%s%v", t.suffix, t.method, t.args)
- }
-
- ipcServer := &server{
- ctx: testContext(),
- disp: testDisp{newEchoInvoker},
- stats: newIPCStats(""),
- }
- for _, test := range tests {
- clientFlow, serverFlow := newTestFlows()
- client := newFlowClient(testContext(), []string{"p0"}, clientFlow, nil)
- server := newFlowServer(serverFlow, ipcServer)
- err := client.start(test.suffix, test.method, test.args, 0, nil)
- if err != nil {
- t.Errorf("%s client.start unexpected error: %v", name(test), err)
- }
- if err := server.serve(); !verror.Equal(err, test.err) {
- t.Errorf("%s server.server returned %v want %v", name(test), err, test.err)
- }
- results := makeResultPtrs(test.expect)
- if err := client.Finish(results...); !verror.Equal(err, test.err) {
- t.Errorf(`%s client.Finish got error "%v", want "%v"`, name(test), err, test.err)
- }
- checkResultPtrs(t, name(test), results, test.expect)
- if clientFlow.numCloseCalls != 1 {
- t.Errorf("%s got %d client close calls, want 1", name(test), clientFlow.numCloseCalls)
- }
- if serverFlow.numCloseCalls != 1 {
- t.Errorf("%s got %d server close calls, want 1", name(test), serverFlow.numCloseCalls)
- }
- }
-}
diff --git a/runtimes/google/ipc/full_test.go b/runtimes/google/ipc/full_test.go
index 02c2633..a5be1c5 100644
--- a/runtimes/google/ipc/full_test.go
+++ b/runtimes/google/ipc/full_test.go
@@ -25,7 +25,6 @@
"veyron.io/veyron/veyron2/vdl/vdlutil"
verror "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
- "veyron.io/veyron/veyron2/vom"
"veyron.io/veyron/veyron/lib/netstate"
"veyron.io/veyron/veyron/lib/testutil"
@@ -374,7 +373,7 @@
func TestRPCServerAuthorization(t *testing.T) {
const (
vcErr = "VC handshake failed"
- nameErr = "does not match the provided pattern"
+ nameErr = "do not match pattern"
)
var (
pprovider, pclient, pserver = tsecurity.NewPrincipal("root"), tsecurity.NewPrincipal(), tsecurity.NewPrincipal()
@@ -1605,5 +1604,5 @@
func init() {
testutil.Init()
- vom.Register(fakeTimeCaveat(0))
+ vdlutil.Register(fakeTimeCaveat(0))
}
diff --git a/runtimes/google/ipc/server.go b/runtimes/google/ipc/server.go
index 78c638f..ca392b5 100644
--- a/runtimes/google/ipc/server.go
+++ b/runtimes/google/ipc/server.go
@@ -20,6 +20,7 @@
"veyron.io/veyron/veyron2/verror"
"veyron.io/veyron/veyron2/vlog"
"veyron.io/veyron/veyron2/vom"
+ "veyron.io/veyron/veyron2/vom2"
"veyron.io/veyron/veyron2/vtrace"
"veyron.io/veyron/veyron/lib/netstate"
@@ -432,12 +433,17 @@
}
calls.Add(1)
go func(flow stream.Flow) {
- if err := newFlowServer(flow, s).serve(); err != nil {
+ defer calls.Done()
+ fs, err := newFlowServer(flow, s)
+ if err != nil {
+ vlog.Errorf("newFlowServer on %v failed: %v", ln, err)
+ return
+ }
+ if err := fs.serve(); err != nil {
// TODO(caprita): Logging errors here is too spammy. For example, "not
// authorized" errors shouldn't be logged as server errors.
vlog.Errorf("Flow serve on %v failed: %v", ln, err)
}
- calls.Done()
}(flow)
}
}
@@ -627,14 +633,23 @@
return firstErr
}
+// TODO(toddw): Remove these interfaces after the vom2 transition.
+type vomEncoder interface {
+ Encode(v interface{}) error
+}
+
+type vomDecoder interface {
+ Decode(v interface{}) error
+}
+
// flowServer implements the RPC server-side protocol for a single RPC, over a
// flow that's already connected to the client.
type flowServer struct {
context.T
server *server // ipc.Server that this flow server belongs to
disp ipc.Dispatcher // ipc.Dispatcher that will serve RPCs on this flow
- dec *vom.Decoder // to decode requests and args from the client
- enc *vom.Encoder // to encode responses and results to the client
+ dec vomDecoder // to decode requests and args from the client
+ enc vomEncoder // to encode responses and results to the client
flow stream.Flow // underlying flow
// Fields filled in during the server invocation.
@@ -649,21 +664,33 @@
var _ ipc.Stream = (*flowServer)(nil)
-func newFlowServer(flow stream.Flow, server *server) *flowServer {
+func newFlowServer(flow stream.Flow, server *server) (*flowServer, error) {
server.Lock()
disp := server.disp
server.Unlock()
- return &flowServer{
- T: server.ctx,
- server: server,
- disp: disp,
- // TODO(toddw): Support different codecs
- dec: vom.NewDecoder(flow),
- enc: vom.NewEncoder(flow),
+ fs := &flowServer{
+ T: server.ctx,
+ server: server,
+ disp: disp,
flow: flow,
discharges: make(map[string]security.Discharge),
}
+ if vom2.IsEnabled() {
+ var err error
+ if fs.dec, err = vom2.NewDecoder(flow); err != nil {
+ flow.Close()
+ return nil, err
+ }
+ if fs.enc, err = vom2.NewBinaryEncoder(flow); err != nil {
+ flow.Close()
+ return nil, err
+ }
+ } else {
+ fs.dec = vom.NewDecoder(flow)
+ fs.enc = vom.NewEncoder(flow)
+ }
+ return fs, nil
}
// Vom does not encode untyped nils.
@@ -677,7 +704,7 @@
// - Server methods return 0 or more results
// - Any values returned by the server that have an interface type are either
// non-nil or of type error.
-func result2vom(res interface{}) vom.Value {
+func vomErrorHack(res interface{}) vom.Value {
v := vom.ValueOf(res)
if !v.IsValid() {
// Untyped nils are assumed to be nil-errors.
@@ -693,6 +720,22 @@
return v
}
+// TODO(toddw): Remove this function and encodeValueHack after the vom2 transition.
+func vom2ErrorHack(res interface{}) interface{} {
+ if err, ok := res.(error); ok {
+ return &err
+ }
+ return res
+}
+
+// TODO(toddw): Remove this function and vom2ErrorHack after the vom2 transition.
+func (fs *flowServer) encodeValueHack(res interface{}) error {
+ if vom2.IsEnabled() {
+ return fs.enc.Encode(vom2ErrorHack(res))
+ }
+ return fs.enc.(*vom.Encoder).EncodeValue(vomErrorHack(res))
+}
+
func (fs *flowServer) serve() error {
defer fs.flow.Close()
@@ -719,7 +762,7 @@
return response.Error
}
for ix, res := range results {
- if err := fs.enc.EncodeValue(result2vom(res)); err != nil {
+ if err := fs.encodeValueHack(res); err != nil {
return verror.BadProtocolf("ipc: result #%d [%T=%v] encoding failed: %v", ix, res, res, err)
}
}
diff --git a/runtimes/google/ipc/stream/proxy/protocol.vdl.go b/runtimes/google/ipc/stream/proxy/protocol.vdl.go
index c5d943f..fefef65 100644
--- a/runtimes/google/ipc/stream/proxy/protocol.vdl.go
+++ b/runtimes/google/ipc/stream/proxy/protocol.vdl.go
@@ -3,12 +3,22 @@
package proxy
+import (
+ // The non-user imports are prefixed with "__" to prevent collisions.
+ __vdl "veyron.io/veyron/veyron2/vdl"
+)
+
// Request is the message sent by a server to request that the proxy route
// traffic intended for the server's RoutingID to the network connection
// between the server and the proxy.
type Request struct {
}
+func (Request) __VDLReflect(struct {
+ Name string "veyron.io/veyron/veyron/runtimes/google/ipc/stream/proxy.Request"
+}) {
+}
+
// Response is sent by the proxy to the server after processing Request.
type Response struct {
// Error is a description of why the proxy refused to proxy the server.
@@ -18,3 +28,13 @@
// used to communicate with the server through the proxy.
Endpoint string
}
+
+func (Response) __VDLReflect(struct {
+ Name string "veyron.io/veyron/veyron/runtimes/google/ipc/stream/proxy.Response"
+}) {
+}
+
+func init() {
+ __vdl.Register(Request{})
+ __vdl.Register(Response{})
+}
diff --git a/security/agent/agent_test.go b/security/agent/agent_test.go
index d3a0b39..3d9fd8c 100644
--- a/security/agent/agent_test.go
+++ b/security/agent/agent_test.go
@@ -4,7 +4,6 @@
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
- "errors"
"reflect"
"testing"
@@ -15,6 +14,7 @@
"veyron.io/veyron/veyron2/options"
"veyron.io/veyron/veyron2/rt"
"veyron.io/veyron/veyron2/security"
+ "veyron.io/veyron/veyron2/verror2"
)
func setupAgent(t *testing.T, p security.Principal) security.Principal {
@@ -39,13 +39,17 @@
Method string
Args V
Result interface{} // Result returned by the Method call.
- Error error // If Error is not nil will be compared to the last result.
+ Error verror2.E // If Error is not nil will be compared to the last result.
}
-var addToRootsErr = errors.New("AddToRoots")
-var storeSetDefaultErr = errors.New("StoreSetDefault")
-var rootsAddErr = errors.New("RootsAdd")
-var rootsRecognizedErr = errors.New("RootsRecognized")
+const pkgPath = "veyron.io/veyron/veyron/security/agent/"
+
+var (
+ addToRootsErr = verror2.Register(pkgPath+".addToRoots", verror2.NoRetry, "")
+ storeSetDefaultErr = verror2.Register(pkgPath+".storeSetDefault", verror2.NoRetry, "")
+ rootsAddErr = verror2.Register(pkgPath+".rootsAdd", verror2.NoRetry, "")
+ rootsRecognizedErr = verror2.Register(pkgPath+".rootsRecognized", verror2.NoRetry, "")
+)
func TestAgent(t *testing.T) {
var (
@@ -56,10 +60,12 @@
tests := []testInfo{
{"BlessSelf", V{"self"}, newBlessing(t, "blessing"), nil},
{"Bless", V{newPrincipal(t).PublicKey(), newBlessing(t, "root"), "extension", security.UnconstrainedUse()}, newBlessing(t, "root/extension"), nil},
+ // TODO(toddw): This change is necessary for vom2:
+ //{"Sign", V{make([]byte, 10)}, security.Signature{Purpose: []byte{}, R: []byte{1}, S: []byte{1}}, nil},
{"Sign", V{make([]byte, 10)}, security.Signature{R: []byte{1}, S: []byte{1}}, nil},
{"MintDischarge", V{thirdPartyCaveat, security.UnconstrainedUse()}, discharge, nil},
{"PublicKey", V{}, mockP.PublicKey(), nil},
- {"AddToRoots", V{newBlessing(t, "blessing")}, nil, addToRootsErr},
+ {"AddToRoots", V{newBlessing(t, "blessing")}, nil, verror2.Make(addToRootsErr, nil)},
}
for _, test := range tests {
mockP.NextResult = test.Result
@@ -71,7 +77,7 @@
storeTests := []testInfo{
{"Set", V{newBlessing(t, "blessing"), security.BlessingPattern("test")}, newBlessing(t, "root/extension"), nil},
{"ForPeer", V{"test", "oink"}, newBlessing(t, "for/peer"), nil},
- {"SetDefault", V{newBlessing(t, "blessing")}, nil, storeSetDefaultErr},
+ {"SetDefault", V{newBlessing(t, "blessing")}, nil, verror2.Make(storeSetDefaultErr, nil)},
{"Default", V{}, newBlessing(t, "root/extension"), nil},
{"PublicKey", V{}, mockP.PublicKey(), nil},
{"DebugString", V{}, "StoreString", nil},
@@ -84,8 +90,8 @@
roots := agent.Roots()
rootTests := []testInfo{
- {"Add", V{newPrincipal(t).PublicKey(), security.BlessingPattern("test")}, nil, rootsAddErr},
- {"Recognized", V{newPrincipal(t).PublicKey(), "blessing"}, nil, rootsRecognizedErr},
+ {"Add", V{newPrincipal(t).PublicKey(), security.BlessingPattern("test")}, nil, verror2.Make(rootsAddErr, nil)},
+ {"Recognized", V{newPrincipal(t).PublicKey(), "blessing"}, nil, verror2.Make(rootsRecognizedErr, nil)},
{"DebugString", V{}, "RootsString", nil},
}
for _, test := range rootTests {
@@ -103,7 +109,7 @@
}
// We only set the error value when error is the only output to ensure the real function gets called.
if test.Error != nil {
- if got := results[len(results)-1]; got == nil || got.(error).Error() != test.Error.Error() {
+ if got := results[len(results)-1]; got == nil || !verror2.Is(got.(error), test.Error.ErrorID()) {
t.Errorf("p.%v(%#v) returned an incorrect error: %v, expected %v", test.Method, test.Args, got, test.Error)
}
if len(results) == 1 {
@@ -111,7 +117,7 @@
}
}
if got := results[0]; !reflect.DeepEqual(got, test.Result) {
- t.Errorf("p.%v(%#v) returned %v(%T) want %v(%T)", test.Method, test.Args, got, got, test.Result, test.Result)
+ t.Errorf("p.%v(%#v) returned %#v want %#v", test.Method, test.Args, got, test.Result)
}
}
diff --git a/security/serialization/verifying_reader.go b/security/serialization/verifying_reader.go
index 2a240b6..e8f1f44 100644
--- a/security/serialization/verifying_reader.go
+++ b/security/serialization/verifying_reader.go
@@ -9,6 +9,7 @@
"io"
"veyron.io/veyron/veyron2/security"
+ "veyron.io/veyron/veyron2/vdl/vdlutil"
"veyron.io/veyron/veyron2/vom"
)
@@ -119,5 +120,5 @@
}
func init() {
- vom.Register([sha256.Size]byte{})
+ vdlutil.Register([sha256.Size]byte{})
}
diff --git a/security/util_test.go b/security/util_test.go
index 6d07a22..194443f 100644
--- a/security/util_test.go
+++ b/security/util_test.go
@@ -9,7 +9,7 @@
"testing"
"veyron.io/veyron/veyron2/security"
- "veyron.io/veyron/veyron2/vom"
+ "veyron.io/veyron/veyron2/vdl/vdlutil"
)
func TestLoadSavePEMKey(t *testing.T) {
@@ -121,6 +121,6 @@
}
func init() {
- vom.Register(&fpCaveat{})
- vom.Register(&tpCaveat{})
+ vdlutil.Register(&fpCaveat{})
+ vdlutil.Register(&tpCaveat{})
}
diff --git a/services/identity/revocation/revocation_manager.go b/services/identity/revocation/revocation_manager.go
index b4b2178..4a45a9a 100644
--- a/services/identity/revocation/revocation_manager.go
+++ b/services/identity/revocation/revocation_manager.go
@@ -9,7 +9,7 @@
"time"
"veyron.io/veyron/veyron2/security"
- "veyron.io/veyron/veyron2/vom"
+ "veyron.io/veyron/veyron2/vdl/vdlutil"
)
// RevocationManager persists information for revocation caveats to provided discharges and allow for future revocations.
@@ -89,5 +89,5 @@
}
func init() {
- vom.Register(revocationCaveat{})
+ vdlutil.Register(revocationCaveat{})
}
diff --git a/services/mgmt/application/impl/impl_test.go b/services/mgmt/application/impl/impl_test.go
index 50e9ce2..9b4395c 100644
--- a/services/mgmt/application/impl/impl_test.go
+++ b/services/mgmt/application/impl/impl_test.go
@@ -9,6 +9,7 @@
"veyron.io/veyron/veyron2/naming"
"veyron.io/veyron/veyron2/rt"
"veyron.io/veyron/veyron2/services/mgmt/application"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron/lib/testutil"
"veyron.io/veyron/veyron/profiles"
@@ -69,7 +70,7 @@
if err := stubV2.Put(ctx, []string{"base"}, envelopeV2); err != nil {
t.Fatalf("Put() failed: %v", err)
}
- if err := stub.Put(ctx, []string{"base", "media"}, envelopeV1); err == nil || err.Error() != errInvalidSuffix.Error() {
+ if err := stub.Put(ctx, []string{"base", "media"}, envelopeV1); err == nil || !verror2.Is(err, errInvalidSuffix.ID) {
t.Fatalf("Unexpected error: expected %v, got %v", errInvalidSuffix, err)
}
@@ -88,13 +89,13 @@
if !reflect.DeepEqual(envelopeV1, output) {
t.Fatalf("Unexpected output: expected %v, got %v", envelopeV1, output)
}
- if _, err := stubV2.Match(ctx, []string{"media"}); err == nil || err.Error() != errNotFound.Error() {
+ if _, err := stubV2.Match(ctx, []string{"media"}); err == nil || !verror2.Is(err, errNotFound.ID) {
t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
}
- if _, err := stubV2.Match(ctx, []string{}); err == nil || err.Error() != errNotFound.Error() {
+ if _, err := stubV2.Match(ctx, []string{}); err == nil || !verror2.Is(err, errNotFound.ID) {
t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
}
- if _, err := stub.Match(ctx, []string{"media"}); err == nil || err.Error() != errInvalidSuffix.Error() {
+ if _, err := stub.Match(ctx, []string{"media"}); err == nil || !verror2.Is(err, errInvalidSuffix.ID) {
t.Fatalf("Unexpected error: expected %v, got %v", errInvalidSuffix, err)
}
@@ -121,13 +122,13 @@
if output, err = stubV1.Match(ctx, []string{"media"}); err != nil {
t.Fatalf("Match() failed: %v", err)
}
- if err := stubV1.Remove(ctx, "base"); err == nil || err.Error() != errNotFound.Error() {
+ if err := stubV1.Remove(ctx, "base"); err == nil || !verror2.Is(err, errNotFound.ID) {
t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
}
if err := stub.Remove(ctx, "base"); err != nil {
t.Fatalf("Remove() failed: %v", err)
}
- if err := stubV2.Remove(ctx, "media"); err == nil || err.Error() != errNotFound.Error() {
+ if err := stubV2.Remove(ctx, "media"); err == nil || !verror2.Is(err, errNotFound.ID) {
t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
}
if err := stubV1.Remove(ctx, "media"); err != nil {
@@ -136,13 +137,13 @@
// Finally, use Match() to test that Remove really removed the
// application envelopes.
- if _, err := stubV1.Match(ctx, []string{"base"}); err == nil || err.Error() != errNotFound.Error() {
+ if _, err := stubV1.Match(ctx, []string{"base"}); err == nil || !verror2.Is(err, errNotFound.ID) {
t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
}
- if _, err := stubV1.Match(ctx, []string{"media"}); err == nil || err.Error() != errNotFound.Error() {
+ if _, err := stubV1.Match(ctx, []string{"media"}); err == nil || !verror2.Is(err, errNotFound.ID) {
t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
}
- if _, err := stubV2.Match(ctx, []string{"base"}); err == nil || err.Error() != errNotFound.Error() {
+ if _, err := stubV2.Match(ctx, []string{"base"}); err == nil || !verror2.Is(err, errNotFound.ID) {
t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
}
diff --git a/services/mgmt/application/impl/service.go b/services/mgmt/application/impl/service.go
index 76c930b..a42dcab 100644
--- a/services/mgmt/application/impl/service.go
+++ b/services/mgmt/application/impl/service.go
@@ -1,13 +1,13 @@
package impl
import (
- "errors"
"strings"
"veyron.io/veyron/veyron/services/mgmt/lib/fs"
"veyron.io/veyron/veyron2/ipc"
"veyron.io/veyron/veyron2/naming"
"veyron.io/veyron/veyron2/services/mgmt/application"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
)
@@ -24,10 +24,12 @@
suffix string
}
+const pkgPath = "veyron.io/veyron/veyron/services/mgmt/application/impl/"
+
var (
- errInvalidSuffix = errors.New("invalid suffix")
- errOperationFailed = errors.New("operation failed")
- errNotFound = errors.New("not found")
+ errInvalidSuffix = verror2.Register(pkgPath+".invalidSuffix", verror2.NoRetry, "")
+ errOperationFailed = verror2.Register(pkgPath+".operationFailed", verror2.NoRetry, "")
+ errNotFound = verror2.Register(pkgPath+".notFound", verror2.NoRetry, "")
)
// NewApplicationService returns a new Application service implementation.
@@ -35,7 +37,7 @@
return &appRepoService{store: store, storeRoot: storeRoot, suffix: suffix}
}
-func parse(suffix string) (string, string, error) {
+func parse(context ipc.ServerContext, suffix string) (string, string, error) {
tokens := strings.Split(suffix, "/")
switch len(tokens) {
case 2:
@@ -43,19 +45,19 @@
case 1:
return tokens[0], "", nil
default:
- return "", "", errInvalidSuffix
+ return "", "", verror2.Make(errInvalidSuffix, context)
}
}
func (i *appRepoService) Match(context ipc.ServerContext, profiles []string) (application.Envelope, error) {
vlog.VI(0).Infof("%v.Match(%v)", i.suffix, profiles)
empty := application.Envelope{}
- name, version, err := parse(i.suffix)
+ name, version, err := parse(context, i.suffix)
if err != nil {
return empty, err
}
if version == "" {
- return empty, errInvalidSuffix
+ return empty, verror2.Make(errInvalidSuffix, context)
}
i.store.Lock()
@@ -73,17 +75,17 @@
}
return envelope, nil
}
- return empty, errNotFound
+ return empty, verror2.Make(errNotFound, context)
}
func (i *appRepoService) Put(context ipc.ServerContext, profiles []string, envelope application.Envelope) error {
vlog.VI(0).Infof("%v.Put(%v, %v)", i.suffix, profiles, envelope)
- name, version, err := parse(i.suffix)
+ name, version, err := parse(context, i.suffix)
if err != nil {
return err
}
if version == "" {
- return errInvalidSuffix
+ return verror2.Make(errInvalidSuffix, context)
}
i.store.Lock()
defer i.store.Unlock()
@@ -99,18 +101,18 @@
object := i.store.BindObject(path)
_, err := object.Put(context, envelope)
if err != nil {
- return errOperationFailed
+ return verror2.Make(errOperationFailed, context)
}
}
if err := i.store.BindTransaction(tname).Commit(context); err != nil {
- return errOperationFailed
+ return verror2.Make(errOperationFailed, context)
}
return nil
}
func (i *appRepoService) Remove(context ipc.ServerContext, profile string) error {
vlog.VI(0).Infof("%v.Remove(%v)", i.suffix, profile)
- name, version, err := parse(i.suffix)
+ name, version, err := parse(context, i.suffix)
if err != nil {
return err
}
@@ -128,16 +130,16 @@
object := i.store.BindObject(path)
found, err := object.Exists(context)
if err != nil {
- return errOperationFailed
+ return verror2.Make(errOperationFailed, context)
}
if !found {
- return errNotFound
+ return verror2.Make(errNotFound, context)
}
if err := object.Remove(context); err != nil {
- return errOperationFailed
+ return verror2.Make(errOperationFailed, context)
}
if err := i.store.BindTransaction(tname).Commit(context); err != nil {
- return errOperationFailed
+ return verror2.Make(errOperationFailed, context)
}
return nil
}
@@ -207,9 +209,9 @@
return nil, nil
}
}
- return nil, errNotFound
+ return nil, verror2.Make(errNotFound, nil)
default:
- return nil, errNotFound
+ return nil, verror2.Make(errNotFound, nil)
}
ch := make(chan string, len(results))
diff --git a/services/mgmt/node/impl/app_service.go b/services/mgmt/node/impl/app_service.go
index dff4976..b5ab1ab 100644
--- a/services/mgmt/node/impl/app_service.go
+++ b/services/mgmt/node/impl/app_service.go
@@ -136,7 +136,7 @@
"veyron.io/veyron/veyron2/services/mgmt/appcycle"
"veyron.io/veyron/veyron2/services/mgmt/application"
"veyron.io/veyron/veyron2/services/security/access"
- "veyron.io/veyron/veyron2/verror"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
vexec "veyron.io/veyron/veyron/lib/exec"
@@ -161,12 +161,12 @@
jsonInfo, err := json.Marshal(info)
if err != nil {
vlog.Errorf("Marshal(%v) failed: %v", info, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
infoPath := filepath.Join(dir, "info")
if err := ioutil.WriteFile(infoPath, jsonInfo, 0600); err != nil {
vlog.Errorf("WriteFile(%v) failed: %v", infoPath, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
@@ -176,10 +176,10 @@
info := new(instanceInfo)
if infoBytes, err := ioutil.ReadFile(infoPath); err != nil {
vlog.Errorf("ReadFile(%v) failed: %v", infoPath, err)
- return nil, errOperationFailed
+ return nil, verror2.Make(ErrOperationFailed, nil)
} else if err := json.Unmarshal(infoBytes, info); err != nil {
vlog.Errorf("Unmarshal(%v) failed: %v", infoBytes, err)
- return nil, errOperationFailed
+ return nil, verror2.Make(ErrOperationFailed, nil)
}
return info, nil
}
@@ -216,12 +216,12 @@
jsonEnvelope, err := json.Marshal(envelope)
if err != nil {
vlog.Errorf("Marshal(%v) failed: %v", envelope, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
path := filepath.Join(dir, "envelope")
if err := ioutil.WriteFile(path, jsonEnvelope, 0600); err != nil {
vlog.Errorf("WriteFile(%v) failed: %v", path, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
@@ -231,10 +231,10 @@
envelope := new(application.Envelope)
if envelopeBytes, err := ioutil.ReadFile(path); err != nil {
vlog.Errorf("ReadFile(%v) failed: %v", path, err)
- return nil, errOperationFailed
+ return nil, verror2.Make(ErrOperationFailed, nil)
} else if err := json.Unmarshal(envelopeBytes, envelope); err != nil {
vlog.Errorf("Unmarshal(%v) failed: %v", envelopeBytes, err)
- return nil, errOperationFailed
+ return nil, verror2.Make(ErrOperationFailed, nil)
}
return envelope, nil
}
@@ -243,7 +243,7 @@
path := filepath.Join(dir, "origin")
if err := ioutil.WriteFile(path, []byte(originVON), 0600); err != nil {
vlog.Errorf("WriteFile(%v) failed: %v", path, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
@@ -252,7 +252,7 @@
path := filepath.Join(dir, "origin")
if originBytes, err := ioutil.ReadFile(path); err != nil {
vlog.Errorf("ReadFile(%v) failed: %v", path, err)
- return "", errOperationFailed
+ return "", verror2.Make(ErrOperationFailed, nil)
} else {
return string(originBytes), nil
}
@@ -318,7 +318,7 @@
if envelope.Title == application.NodeManagerTitle {
// Disallow node manager apps from being installed like a
// regular app.
- return nil, errInvalidOperation
+ return nil, verror2.Make(ErrInvalidOperation, ctx)
}
return envelope, nil
}
@@ -327,11 +327,11 @@
func newVersion(installationDir string, envelope *application.Envelope, oldVersionDir string) (string, error) {
versionDir := filepath.Join(installationDir, generateVersionDirName())
if err := mkdir(versionDir); err != nil {
- return "", errOperationFailed
+ return "", verror2.Make(ErrOperationFailed, nil)
}
pkgDir := filepath.Join(versionDir, "pkg")
if err := mkdir(pkgDir); err != nil {
- return "", errOperationFailed
+ return "", verror2.Make(ErrOperationFailed, nil)
}
// TODO(caprita): Share binaries if already existing locally.
if err := downloadBinary(versionDir, "bin", envelope.Binary); err != nil {
@@ -340,12 +340,12 @@
for localPkg, pkgName := range envelope.Packages {
if localPkg == "" || localPkg[0] == '.' || strings.Contains(localPkg, string(filepath.Separator)) {
vlog.Infof("invalid local package name: %q", localPkg)
- return versionDir, errOperationFailed
+ return versionDir, verror2.Make(ErrOperationFailed, nil)
}
path := filepath.Join(pkgDir, localPkg)
if err := libbinary.DownloadToFile(rt.R().NewContext(), pkgName, path); err != nil {
vlog.Infof("DownloadToFile(%q, %q) failed: %v", pkgName, path, err)
- return versionDir, errOperationFailed
+ return versionDir, verror2.Make(ErrOperationFailed, nil)
}
}
if err := saveEnvelope(versionDir, envelope); err != nil {
@@ -355,7 +355,7 @@
previousLink := filepath.Join(versionDir, "previous")
if err := os.Symlink(oldVersionDir, previousLink); err != nil {
vlog.Errorf("Symlink(%v, %v) failed: %v", oldVersionDir, previousLink, err)
- return versionDir, errOperationFailed
+ return versionDir, verror2.Make(ErrOperationFailed, nil)
}
}
// updateLink should be the last thing we do, after we've ensured the
@@ -380,7 +380,7 @@
func (i *appService) Install(call ipc.ServerContext, applicationVON string) (string, error) {
if len(i.suffix) > 0 {
- return "", errInvalidSuffix
+ return "", verror2.Make(ErrInvalidSuffix, call)
}
ctx, cancel := rt.R().NewContext().WithTimeout(ipcContextTimeout)
defer cancel()
@@ -433,23 +433,23 @@
file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, perm)
if err != nil {
vlog.Errorf("OpenFile(%v) failed: %v", path, err)
- return nil, errOperationFailed
+ return nil, verror2.Make(ErrOperationFailed, nil)
}
return file, nil
}
func installationDirCore(components []string, root string) (string, error) {
if nComponents := len(components); nComponents != 2 {
- return "", errInvalidSuffix
+ return "", verror2.Make(ErrInvalidSuffix, nil)
}
app, installation := components[0], components[1]
installationDir := filepath.Join(root, applicationDirName(app), installationDirName(installation))
if _, err := os.Stat(installationDir); err != nil {
if os.IsNotExist(err) {
- return "", errNotExist
+ return "", verror2.Make(ErrObjectNoExist, nil)
}
vlog.Errorf("Stat(%v) failed: %v", installationDir, err)
- return "", errOperationFailed
+ return "", verror2.Make(ErrOperationFailed, nil)
}
return installationDir, nil
}
@@ -465,13 +465,13 @@
client, err := rt.R().NewClient(options.VCSecurityNone)
if err != nil {
vlog.Errorf("NewClient() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
defer client.Close()
// TODO(caprita): release the socket created by NewAgentPrincipal.
if p, err = agent.NewAgentPrincipal(client, int(conn.Fd()), rt.R().NewContext()); err != nil {
vlog.Errorf("NewAgentPrincipal() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
info.SecurityAgentHandle = handle
} else {
@@ -481,7 +481,7 @@
var err error
if p, err = vsecurity.CreatePersistentPrincipal(credentialsDir, nil); err != nil {
vlog.Errorf("CreatePersistentPrincipal(%v, nil) failed: %v", credentialsDir, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
}
// Read the app installation version's envelope to obtain the app title.
@@ -498,27 +498,27 @@
// with the app title.
grantedBlessings := call.Blessings()
if grantedBlessings == nil {
- return errInvalidBlessing
+ return verror2.Make(ErrInvalidBlessing, nil)
}
// TODO(caprita): Revisit UnconstrainedUse.
appBlessings, err := nmPrincipal.Bless(p.PublicKey(), grantedBlessings, envelope.Title, security.UnconstrainedUse())
if err != nil {
vlog.Errorf("Bless() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
// The blessings we extended from the blessings that the Start-er
// granted are the default blessings for the app.
if err := p.BlessingStore().SetDefault(appBlessings); err != nil {
vlog.Errorf("BlessingStore.SetDefault() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
if _, err := p.BlessingStore().Set(appBlessings, security.AllPrincipals); err != nil {
vlog.Errorf("BlessingStore.Set() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
if err := p.AddToRoots(appBlessings); err != nil {
vlog.Errorf("AddToRoots() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
// In addition, we give the app separate blessings for the purpose of
// communicating with the node manager.
@@ -541,7 +541,7 @@
for _, n := range names {
if _, err := p.BlessingStore().Set(nmBlessings, security.BlessingPattern(n)); err != nil {
vlog.Errorf("BlessingStore.Set() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
}
// We also want to override the app cycle manager's server blessing in
@@ -551,16 +551,16 @@
randomPattern, err := generateRandomString()
if err != nil {
vlog.Errorf("generateRandomString() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
if _, err := p.BlessingStore().Set(nmBlessings, security.BlessingPattern(randomPattern)); err != nil {
vlog.Errorf("BlessingStore.Set() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
info.NodeManagerPeerPattern = randomPattern
if err := p.AddToRoots(nmBlessings); err != nil {
vlog.Errorf("AddToRoots() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
@@ -617,27 +617,27 @@
return "", "", err
}
if !installationStateIs(installationDir, active) {
- return "", "", errInvalidOperation
+ return "", "", verror2.Make(ErrInvalidOperation, call)
}
instanceID := generateID()
instanceDir := filepath.Join(installationDir, "instances", instanceDirName(instanceID))
if mkdir(instanceDir) != nil {
- return "", instanceID, errOperationFailed
+ return "", instanceID, verror2.Make(ErrOperationFailed, call)
}
currLink := filepath.Join(installationDir, "current")
versionDir, err := filepath.EvalSymlinks(currLink)
if err != nil {
vlog.Errorf("EvalSymlinks(%v) failed: %v", currLink, err)
- return instanceDir, instanceID, errOperationFailed
+ return instanceDir, instanceID, verror2.Make(ErrOperationFailed, call)
}
versionLink := filepath.Join(instanceDir, "version")
if err := os.Symlink(versionDir, versionLink); err != nil {
vlog.Errorf("Symlink(%v, %v) failed: %v", versionDir, versionLink, err)
- return instanceDir, instanceID, errOperationFailed
+ return instanceDir, instanceID, verror2.Make(ErrOperationFailed, call)
}
if err := installPackages(versionDir, instanceDir); err != nil {
vlog.Errorf("installPackages(%v, %v) failed: %v", versionDir, instanceDir, err)
- return instanceDir, instanceID, errOperationFailed
+ return instanceDir, instanceID, verror2.Make(ErrOperationFailed, call)
}
instanceInfo := new(instanceInfo)
if err := setupPrincipal(instanceDir, versionDir, call, i.securityAgent, instanceInfo); err != nil {
@@ -671,11 +671,12 @@
// and is probably not a good fit in other contexts. Revisit the design
// as appropriate. This function also internalizes a decision as to when
// it is possible to start an application that needs to be made explicit.
-func systemAccountForHelper(helperPath string, identityNames []string, uat BlessingSystemAssociationStore) (systemName string, err error) {
+func systemAccountForHelper(ctx ipc.ServerContext, helperPath string, uat BlessingSystemAssociationStore) (systemName string, err error) {
+ identityNames := ctx.RemoteBlessings().ForContext(ctx)
helperStat, err := os.Stat(helperPath)
if err != nil {
vlog.Errorf("Stat(%v) failed: %v. helper is required.", helperPath, err)
- return "", errOperationFailed
+ return "", verror2.Make(ErrOperationFailed, ctx)
}
haveHelper := isSetuid(helperStat)
systemName, present := uat.SystemAccountForBlessings(identityNames)
@@ -688,7 +689,7 @@
// Therefore, the node manager must never run an app as itself to
// prevent an app trivially granting itself root permissions.
// There must be an associated uname for the account in this case.
- return "", verror.NoAccessf("use of setuid helper requires an associated uname.")
+ return "", verror2.Make(verror2.NoAccess, ctx, "use of setuid helper requires an associated uname.")
case !haveHelper:
// When the helper is not setuid, the helper can't change the
// app's uid so just run the app as the node manager's uname
@@ -697,11 +698,11 @@
user, err := user.Current()
if err != nil {
vlog.Errorf("user.Current() failed: %v", err)
- return "", errOperationFailed
+ return "", verror2.Make(ErrOperationFailed, ctx)
}
return user.Username, nil
}
- return "", errOperationFailed
+ return "", verror2.Make(ErrOperationFailed, ctx)
}
func genCmd(instanceDir, helperPath, systemName string) (*exec.Cmd, error) {
@@ -709,7 +710,7 @@
versionDir, err := filepath.EvalSymlinks(versionLink)
if err != nil {
vlog.Errorf("EvalSymlinks(%v) failed: %v", versionLink, err)
- return nil, errOperationFailed
+ return nil, verror2.Make(ErrOperationFailed, nil)
}
envelope, err := loadEnvelope(versionDir)
if err != nil {
@@ -718,7 +719,7 @@
binPath := filepath.Join(versionDir, "bin")
if _, err := os.Stat(binPath); err != nil {
vlog.Errorf("Stat(%v) failed: %v", binPath, err)
- return nil, errOperationFailed
+ return nil, verror2.Make(ErrOperationFailed, nil)
}
cmd := exec.Command(helperPath)
@@ -818,7 +819,7 @@
agentCleaner()
}
vlog.Errorf("Start() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
if agentCleaner != nil {
agentCleaner()
@@ -827,11 +828,11 @@
// Wait for the child process to start.
if err := handle.WaitForReady(childReadyTimeout); err != nil {
vlog.Errorf("WaitForReady(%v) failed: %v", childReadyTimeout, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
childName, err := listener.waitForValue(childReadyTimeout)
if err != nil {
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
info.AppCycleMgrName, info.Pid = childName, handle.Pid()
if err := saveInstanceInfo(instanceDir, info); err != nil {
@@ -868,7 +869,7 @@
return nil, err
}
- systemName, err := systemAccountForHelper(helper, call.RemoteBlessings().ForContext(call), i.uat)
+ systemName, err := systemAccountForHelper(call, helper, i.uat)
if err != nil {
cleanupDir(instanceDir, helper)
return nil, err
@@ -893,7 +894,7 @@
// referred to by the given suffix relative to the given root directory.
func instanceDir(root string, suffix []string) (string, error) {
if nComponents := len(suffix); nComponents != 3 {
- return "", errInvalidSuffix
+ return "", verror2.Make(ErrInvalidSuffix, nil)
}
app, installation, instance := suffix[0], suffix[1], suffix[2]
instancesDir := filepath.Join(root, applicationDirName(app), installationDirName(installation), "instances")
@@ -914,7 +915,7 @@
return err
}
- systemName, err := systemAccountForHelper(i.config.Helper, call.RemoteBlessings().ForContext(call), i.uat)
+ systemName, err := systemAccountForHelper(call, i.config.Helper, i.uat)
if err != nil {
return err
}
@@ -925,7 +926,7 @@
}
if startSystemName != systemName {
- return verror.NoAccessf("Not allowed to resume an application under a different system name.")
+ return verror2.Make(verror2.NoAccess, call, "Not allowed to resume an application under a different system name.")
}
return i.run(instanceDir, systemName)
}
@@ -937,7 +938,7 @@
stream, err := appStub.Stop(ctx)
if err != nil {
vlog.Errorf("%v.Stop() failed: %v", appVON, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
rstream := stream.RecvStream()
for rstream.Advance() {
@@ -945,11 +946,11 @@
}
if err := rstream.Err(); err != nil {
vlog.Errorf("Advance() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
if err := stream.Finish(); err != nil {
vlog.Errorf("Finish() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
@@ -969,7 +970,7 @@
if err != nil {
return err
}
- if err := transitionInstance(instanceDir, suspended, stopped); err == errOperationFailed || err == nil {
+ if err := transitionInstance(instanceDir, suspended, stopped); verror2.Is(err, ErrOperationFailed.ID) || err == nil {
return err
}
if err := transitionInstance(instanceDir, started, stopping); err != nil {
@@ -1005,13 +1006,13 @@
return transitionInstallation(installationDir, active, uninstalled)
}
-func (i *appService) Update(ipc.ServerContext) error {
+func (i *appService) Update(call ipc.ServerContext) error {
installationDir, err := i.installationDir()
if err != nil {
return err
}
if !installationStateIs(installationDir, active) {
- return errInvalidOperation
+ return verror2.Make(ErrInvalidOperation, call)
}
originVON, err := loadOrigin(installationDir)
if err != nil {
@@ -1027,7 +1028,7 @@
oldVersionDir, err := filepath.EvalSymlinks(currLink)
if err != nil {
vlog.Errorf("EvalSymlinks(%v) failed: %v", currLink, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, call)
}
// NOTE(caprita): A race can occur between two competing updates, where
// both use the old version as their baseline. This can result in both
@@ -1042,10 +1043,10 @@
return err
}
if oldEnvelope.Title != newEnvelope.Title {
- return errIncompatibleUpdate
+ return verror2.Make(ErrAppTitleMismatch, call)
}
if reflect.DeepEqual(oldEnvelope, newEnvelope) {
- return errUpdateNoOp
+ return verror2.Make(ErrUpdateNoOp, call)
}
versionDir, err := newVersion(installationDir, newEnvelope, oldVersionDir)
if err != nil {
@@ -1060,13 +1061,13 @@
return nil
}
-func (i *appService) Revert(ipc.ServerContext) error {
+func (i *appService) Revert(ctx ipc.ServerContext) error {
installationDir, err := i.installationDir()
if err != nil {
return err
}
if !installationStateIs(installationDir, active) {
- return errInvalidOperation
+ return verror2.Make(ErrInvalidOperation, ctx)
}
// NOTE(caprita): A race can occur between an update and a revert, where
// both use the same current version as their starting point. This will
@@ -1077,21 +1078,21 @@
currVersionDir, err := filepath.EvalSymlinks(currLink)
if err != nil {
vlog.Errorf("EvalSymlinks(%v) failed: %v", currLink, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
previousLink := filepath.Join(currVersionDir, "previous")
if _, err := os.Lstat(previousLink); err != nil {
if os.IsNotExist(err) {
// No 'previous' link -- must be the first version.
- return errUpdateNoOp
+ return verror2.Make(ErrUpdateNoOp, ctx)
}
vlog.Errorf("Lstat(%v) failed: %v", previousLink, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
prevVersionDir, err := filepath.EvalSymlinks(previousLink)
if err != nil {
vlog.Errorf("EvalSymlinks(%v) failed: %v", previousLink, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
return updateLink(prevVersionDir, currLink)
}
@@ -1210,11 +1211,11 @@
}
i.scanInstance(tree, i.suffix[0], dir)
default:
- return nil, errNotExist
+ return nil, verror2.Make(ErrObjectNoExist, nil)
}
n := tree.find(i.suffix, false)
if n == nil {
- return nil, errInvalidSuffix
+ return nil, verror2.Make(ErrInvalidSuffix, nil)
}
ch := make(chan string, 100)
go func() {
@@ -1243,7 +1244,7 @@
}
return p, nil
}
- return "", errInvalidSuffix
+ return "", verror2.Make(ErrInvalidSuffix, nil)
}
// TODO(rjkroege): Consider maintaining an in-memory ACL cache.
diff --git a/services/mgmt/node/impl/app_state.go b/services/mgmt/node/impl/app_state.go
index 9fbc1c2..63071ca 100644
--- a/services/mgmt/node/impl/app_state.go
+++ b/services/mgmt/node/impl/app_state.go
@@ -6,6 +6,7 @@
"os"
"path/filepath"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
)
@@ -98,10 +99,10 @@
targetState := filepath.Join(dir, target.String())
if err := os.Rename(initialState, targetState); err != nil {
if os.IsNotExist(err) {
- return errInvalidOperation
+ return verror2.Make(ErrInvalidOperation, nil)
}
vlog.Errorf("Rename(%v, %v) failed: %v", initialState, targetState, err) // Something went really wrong.
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
@@ -110,7 +111,7 @@
initialStatus := filepath.Join(dir, initial.String())
if err := ioutil.WriteFile(initialStatus, []byte("status"), 0600); err != nil {
vlog.Errorf("WriteFile(%v) failed: %v", initialStatus, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
diff --git a/services/mgmt/node/impl/association_instance.go b/services/mgmt/node/impl/association_instance.go
index 02ae3a7..32dd993 100644
--- a/services/mgmt/node/impl/association_instance.go
+++ b/services/mgmt/node/impl/association_instance.go
@@ -7,6 +7,7 @@
"io/ioutil"
"path/filepath"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
)
@@ -14,7 +15,7 @@
snp := filepath.Join(dir, "systemname")
if err := ioutil.WriteFile(snp, []byte(systemName), 0600); err != nil {
vlog.Errorf("WriteFile(%v, %v) failed: %v", snp, systemName, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
@@ -24,7 +25,7 @@
name, err := ioutil.ReadFile(snp)
if err != nil {
vlog.Errorf("ReadFile(%v) failed: %v", snp, err)
- return "", errOperationFailed
+ return "", verror2.Make(ErrOperationFailed, nil)
}
return string(name), nil
}
diff --git a/services/mgmt/node/impl/association_state.go b/services/mgmt/node/impl/association_state.go
index 8fe738f..1e9a285 100644
--- a/services/mgmt/node/impl/association_state.go
+++ b/services/mgmt/node/impl/association_state.go
@@ -1,13 +1,13 @@
package impl
import (
+ "encoding/json"
"os"
"path/filepath"
- "veyron.io/veyron/veyron2/services/mgmt/node"
- "veyron.io/veyron/veyron2/verror"
-
- "encoding/json"
"sync"
+
+ "veyron.io/veyron/veyron2/services/mgmt/node"
+ "veyron.io/veyron/veyron2/verror2"
)
// BlessingSystemAssociationStore manages a persisted association between
@@ -65,7 +65,7 @@
func (u *association) serialize() (err error) {
f, err := os.OpenFile(u.filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
- return verror.NoExistf("Could not open association file for writing %s: %v", u.filename, err)
+ return verror2.Make(verror2.NoExist, nil, "Could not open association file for writing", u.filename, err)
}
defer func() {
if closerr := f.Close(); closerr != nil {
@@ -100,13 +100,13 @@
func NewBlessingSystemAssociationStore(root string) (BlessingSystemAssociationStore, error) {
nddir := filepath.Join(root, "node-manager", "node-data")
if err := os.MkdirAll(nddir, os.FileMode(0700)); err != nil {
- return nil, verror.NoExistf("Could not create node-data directory %s: %v\n", nddir, err)
+ return nil, verror2.Make(verror2.NoExist, nil, "Could not create node-data directory", nddir, err)
}
msf := filepath.Join(nddir, "associated.accounts")
f, err := os.Open(msf)
if err != nil && os.IsExist(err) {
- return nil, verror.NoExistf("Could not open association file %s: %v\n", msf, err)
+ return nil, verror2.Make(verror2.NoExist, nil, "Could not open association file", msf, err)
}
defer f.Close()
@@ -117,7 +117,7 @@
dec := json.NewDecoder(f)
err := dec.Decode(&a.data)
if err != nil {
- return nil, verror.NoExistf("Could not read association file %s: %v\n", msf, err)
+ return nil, verror2.Make(verror2.NoExist, nil, "Could not read association file", msf, err)
}
}
return BlessingSystemAssociationStore(a), nil
diff --git a/services/mgmt/node/impl/config_service.go b/services/mgmt/node/impl/config_service.go
index 609e1c6..b7c504d 100644
--- a/services/mgmt/node/impl/config_service.go
+++ b/services/mgmt/node/impl/config_service.go
@@ -12,6 +12,7 @@
"veyron.io/veyron/veyron2/ipc"
"veyron.io/veyron/veyron2/naming"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
)
@@ -64,7 +65,7 @@
return value, nil
case <-time.After(timeout):
vlog.Errorf("Waiting for callback timed out")
- return "", errOperationFailed
+ return "", verror2.Make(ErrOperationFailed, nil)
}
}
@@ -127,7 +128,7 @@
i.callback.Lock()
if _, ok := i.callback.channels[id]; !ok {
i.callback.Unlock()
- return errInvalidSuffix
+ return verror2.Make(ErrInvalidSuffix, nil)
}
channel, ok := i.callback.channels[id][key]
i.callback.Unlock()
diff --git a/services/mgmt/node/impl/dispatcher.go b/services/mgmt/node/impl/dispatcher.go
index deeddcd..45b2bd2 100644
--- a/services/mgmt/node/impl/dispatcher.go
+++ b/services/mgmt/node/impl/dispatcher.go
@@ -29,6 +29,7 @@
"veyron.io/veyron/veyron2/services/mgmt/stats"
"veyron.io/veyron/veyron2/services/security/access"
"veyron.io/veyron/veyron2/verror"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
)
@@ -71,18 +72,19 @@
appsSuffix = "apps"
nodeSuffix = "nm"
configSuffix = "cfg"
+
+ pkgPath = "veyron.io/veyron/veyron/services/mgmt/node/impl"
)
var (
- errInvalidSuffix = verror.BadArgf("invalid suffix")
- errOperationFailed = verror.Internalf("operation failed")
- errInProgress = verror.Existsf("operation in progress")
- errIncompatibleUpdate = verror.BadArgf("update failed: mismatching app title")
- // TODO(bprosnitz) Remove the TODO blocks in util_test when these are upgraded to verror2
- errUpdateNoOp = verror.NoExistf("no different version available")
- errNotExist = verror.NoExistf("object does not exist")
- errInvalidOperation = verror.BadArgf("invalid operation")
- errInvalidBlessing = verror.BadArgf("invalid claim blessing")
+ ErrInvalidSuffix = verror2.Register(pkgPath+".InvalidSuffix", verror2.NoRetry, "")
+ ErrOperationFailed = verror2.Register(pkgPath+".OperationFailed", verror2.NoRetry, "")
+ ErrOperationInProgress = verror2.Register(pkgPath+".OperationInProgress", verror2.NoRetry, "")
+ ErrAppTitleMismatch = verror2.Register(pkgPath+".AppTitleMismatch", verror2.NoRetry, "")
+ ErrUpdateNoOp = verror2.Register(pkgPath+".UpdateNoOp", verror2.NoRetry, "")
+ ErrObjectNoExist = verror2.Register(pkgPath+".ObjectNoExist", verror2.NoRetry, "")
+ ErrInvalidOperation = verror2.Register(pkgPath+".InvalidOperation", verror2.NoRetry, "")
+ ErrInvalidBlessing = verror2.Register(pkgPath+".InvalidBlessing", verror2.NoRetry, "")
)
// NewDispatcher is the node manager dispatcher factory.
@@ -161,7 +163,7 @@
// TODO(rjkroege): Scrub the state tree of installation and instance ACL files.
if len(names) == 0 {
vlog.Errorf("No names for claimer(%v) are trusted", proof)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
rt.R().Principal().BlessingStore().Set(proof, security.AllPrincipals)
rt.R().Principal().BlessingStore().SetDefault(proof)
@@ -175,11 +177,11 @@
_, etag, err := d.getACL()
if err != nil {
vlog.Errorf("Failed to getACL:%v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
if err := d.setACL(acl, etag, true /* store ACL on disk */); err != nil {
vlog.Errorf("Failed to setACL:%v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
@@ -274,27 +276,27 @@
data, err := ioutil.TempFile(dir, "data")
if err != nil {
vlog.Errorf("Failed to open tmpfile data:%v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
defer os.Remove(data.Name())
sig, err := ioutil.TempFile(dir, "sig")
if err != nil {
vlog.Errorf("Failed to open tmpfile sig:%v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
defer os.Remove(sig.Name())
writer, err := serialization.NewSigningWriteCloser(data, sig, rt.R().Principal(), nil)
if err != nil {
vlog.Errorf("Failed to create NewSigningWriteCloser:%v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
if err = acl.WriteTo(writer); err != nil {
vlog.Errorf("Failed to SaveACL:%v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
if err = writer.Close(); err != nil {
vlog.Errorf("Failed to Close() SigningWriteCloser:%v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
if err := os.Rename(data.Name(), aclFile); err != nil {
return err
@@ -383,7 +385,7 @@
return nil, nil, err
}
if !instanceStateIs(appInstanceDir, started) {
- return nil, nil, errInvalidSuffix
+ return nil, nil, verror2.Make(ErrInvalidSuffix, nil)
}
var sigStub signatureStub
if kind == "pprof" {
@@ -416,7 +418,7 @@
return receiver, appSpecificAuthorizer, nil
case configSuffix:
if len(components) != 2 {
- return nil, nil, errInvalidSuffix
+ return nil, nil, verror2.Make(ErrInvalidSuffix, nil)
}
receiver := inode.ConfigServer(&configService{
callback: d.internal.callback,
@@ -431,7 +433,7 @@
// (and not other apps).
return receiver, nil, nil
default:
- return nil, nil, errInvalidSuffix
+ return nil, nil, verror2.Make(ErrInvalidSuffix, nil)
}
}
@@ -459,7 +461,7 @@
}
return access.TaggedACLAuthorizerFromFile(path.Join(p, "acls", "data"), access.TypicalTagType())
}
- return nil, errInvalidSuffix
+ return nil, verror2.Make(ErrInvalidSuffix, nil)
}
// allowEveryone implements the authorization policy that allows all principals
diff --git a/services/mgmt/node/impl/impl_test.go b/services/mgmt/node/impl/impl_test.go
index 06eb18a..d753fd5 100644
--- a/services/mgmt/node/impl/impl_test.go
+++ b/services/mgmt/node/impl/impl_test.go
@@ -38,9 +38,9 @@
"veyron.io/veyron/veyron2/services/mgmt/pprof"
"veyron.io/veyron/veyron2/services/mgmt/stats"
"veyron.io/veyron/veyron2/services/security/access"
+ "veyron.io/veyron/veyron2/vdl/vdlutil"
"veyron.io/veyron/veyron2/verror"
"veyron.io/veyron/veyron2/vlog"
- "veyron.io/veyron/veyron2/vom"
"veyron.io/veyron/veyron/lib/expect"
"veyron.io/veyron/veyron/lib/modules"
@@ -61,7 +61,7 @@
func init() {
// TODO(rthellend): Remove when vom2 is ready.
- vom.Register(&naming.VDLMountedServer{})
+ vdlutil.Register(&naming.VDLMountedServer{})
modules.RegisterChild(execScriptCmd, "", execScript)
modules.RegisterChild(nodeManagerCmd, "", nodeManager)
@@ -341,8 +341,8 @@
// Simulate an invalid envelope in the application repository.
*envelope = envelopeFromShell(sh, nmPauseBeforeStopEnv, nodeManagerCmd, "bogus", nmArgs...)
- updateNodeExpectError(t, "factoryNM", verror.BadArg) // Incorrect title.
- revertNodeExpectError(t, "factoryNM", verror.NoExist) // No previous version available.
+ updateNodeExpectError(t, "factoryNM", impl.ErrAppTitleMismatch.ID)
+ revertNodeExpectError(t, "factoryNM", impl.ErrUpdateNoOp.ID)
// Set up a second version of the node manager. The information in the
// envelope will be used by the node manager to stage the next version.
@@ -364,7 +364,7 @@
t.Fatalf("current link didn't change")
}
- updateNodeExpectError(t, "factoryNM", verror.Exists) // Update already in progress.
+ updateNodeExpectError(t, "factoryNM", impl.ErrOperationInProgress.ID)
nmh.CloseStdin()
@@ -382,7 +382,7 @@
// Try issuing an update without changing the envelope in the application
// repository: this should fail, and current link should be unchanged.
- updateNodeExpectError(t, "v2NM", naming.ErrNoSuchName.ID)
+ updateNodeExpectError(t, "v2NM", impl.ErrUpdateNoOp.ID)
if evalLink() != scriptPathV2 {
t.Fatalf("script changed")
}
@@ -415,7 +415,7 @@
// Revert the node manager to its previous version (v2).
revertNode(t, "v3NM")
- revertNodeExpectError(t, "v3NM", verror.Exists) // Revert already in progress.
+ revertNodeExpectError(t, "v3NM", impl.ErrOperationInProgress.ID) // Revert already in progress.
nmh.CloseStdin()
nms.Expect("v3NM terminating")
if evalLink() != scriptPathV2 {
@@ -554,8 +554,8 @@
appID := installApp(t)
// Start requires the caller to grant a blessing for the app instance.
- if _, err := startAppImpl(t, appID, ""); err == nil || !verror.Is(err, verror.BadArg) {
- t.Fatalf("Start(%v) expected to fail with %v, got %v instead", appID, verror.BadArg, err)
+ if _, err := startAppImpl(t, appID, ""); err == nil || !verror.Is(err, impl.ErrInvalidBlessing.ID) {
+ t.Fatalf("Start(%v) expected to fail with %v, got %v instead", appID, impl.ErrInvalidBlessing.ID, err)
}
// Start an instance of the app.
@@ -606,12 +606,12 @@
}
// Updating the installation to itself is a no-op.
- updateAppExpectError(t, appID, naming.ErrNoSuchName.ID)
+ updateAppExpectError(t, appID, impl.ErrUpdateNoOp.ID)
// Updating the installation should not work with a mismatched title.
*envelope = envelopeFromShell(sh, nil, appCmd, "bogus")
- updateAppExpectError(t, appID, verror.BadArg)
+ updateAppExpectError(t, appID, impl.ErrAppTitleMismatch.ID)
// Create a second version of the app and update the app to it.
*envelope = envelopeFromShell(sh, nil, appCmd, "google naps", "appV2")
@@ -673,19 +673,19 @@
resolveExpectNotFound(t, "appV1")
// We are already on the first version, no further revert possible.
- revertAppExpectError(t, appID, naming.ErrNoSuchName.ID)
+ revertAppExpectError(t, appID, impl.ErrUpdateNoOp.ID)
// Uninstall the app.
uninstallApp(t, appID)
// Updating the installation should no longer be allowed.
- updateAppExpectError(t, appID, verror.BadArg)
+ updateAppExpectError(t, appID, impl.ErrInvalidOperation.ID)
// Reverting the installation should no longer be allowed.
- revertAppExpectError(t, appID, verror.BadArg)
+ revertAppExpectError(t, appID, impl.ErrInvalidOperation.ID)
// Starting new instances should no longer be allowed.
- startAppExpectError(t, appID, verror.BadArg)
+ startAppExpectError(t, appID, impl.ErrInvalidOperation.ID)
// Cleanly shut down the node manager.
syscall.Kill(nmh.Pid(), syscall.SIGINT)
@@ -921,7 +921,7 @@
// sent to their children and so on.
pid := readPID(t, nms)
resolve(t, "nm", 1)
- revertNodeExpectError(t, "nm", naming.ErrNoSuchName.ID) // No previous version available.
+ revertNodeExpectError(t, "nm", impl.ErrUpdateNoOp.ID) // No previous version available.
syscall.Kill(pid, syscall.SIGINT)
nms.Expect("nm terminating")
diff --git a/services/mgmt/node/impl/mock_repo_test.go b/services/mgmt/node/impl/mock_repo_test.go
index 6de199e..d55e2c9 100644
--- a/services/mgmt/node/impl/mock_repo_test.go
+++ b/services/mgmt/node/impl/mock_repo_test.go
@@ -3,7 +3,6 @@
import (
"crypto/md5"
"encoding/hex"
- "errors"
"io"
"io/ioutil"
"os"
@@ -13,6 +12,7 @@
"veyron.io/veyron/veyron2/services/mgmt/application"
"veyron.io/veyron/veyron2/services/mgmt/binary"
"veyron.io/veyron/veyron2/services/mgmt/repository"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
)
@@ -80,6 +80,11 @@
// BINARY REPOSITORY INTERFACE IMPLEMENTATION
+// TODO(toddw): Move the errors from dispatcher.go into a common location.
+const pkgPath = "veyron.io/veyron/veyron/services/mgmt/node/impl"
+
+var ErrOperationFailed = verror2.Register(pkgPath+".OperationFailed", verror2.NoRetry, "")
+
func (*brInvoker) Create(ipc.ServerContext, int32, repository.MediaInfo) error {
vlog.VI(1).Infof("Create()")
return nil
@@ -90,14 +95,12 @@
return nil
}
-var errOperationFailed = errors.New("operation failed")
-
func (i *brInvoker) Download(ctx repository.BinaryDownloadContext, _ int32) error {
vlog.VI(1).Infof("Download()")
file, err := os.Open(os.Args[0])
if err != nil {
vlog.Errorf("Open() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
defer file.Close()
bufferLength := 4096
@@ -111,11 +114,11 @@
case nil:
if err := sender.Send(buffer[:n]); err != nil {
vlog.Errorf("Send() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
default:
vlog.Errorf("Read() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
}
}
@@ -125,12 +128,12 @@
return "", 0, nil
}
-func (*brInvoker) Stat(ipc.ServerContext) ([]binary.PartInfo, repository.MediaInfo, error) {
+func (*brInvoker) Stat(ctx ipc.ServerContext) ([]binary.PartInfo, repository.MediaInfo, error) {
vlog.VI(1).Infof("Stat()")
h := md5.New()
bytes, err := ioutil.ReadFile(os.Args[0])
if err != nil {
- return []binary.PartInfo{}, repository.MediaInfo{}, errOperationFailed
+ return []binary.PartInfo{}, repository.MediaInfo{}, verror2.Make(ErrOperationFailed, ctx)
}
h.Write(bytes)
part := binary.PartInfo{Checksum: hex.EncodeToString(h.Sum(nil)), Size: int64(len(bytes))}
diff --git a/services/mgmt/node/impl/node_service.go b/services/mgmt/node/impl/node_service.go
index 0d4799a..e99b5b3 100644
--- a/services/mgmt/node/impl/node_service.go
+++ b/services/mgmt/node/impl/node_service.go
@@ -47,6 +47,7 @@
"veyron.io/veyron/veyron2/services/mgmt/binary"
"veyron.io/veyron/veyron2/services/mgmt/node"
"veyron.io/veyron/veyron2/services/security/access"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
vexec "veyron.io/veyron/veyron/lib/exec"
@@ -97,7 +98,7 @@
// Get the blessing to be used by the claimant.
blessings := call.Blessings()
if blessings == nil {
- return errInvalidBlessing
+ return verror2.Make(ErrInvalidBlessing, call)
}
return i.disp.claimNodeManager(blessings.ForContext(call), blessings)
}
@@ -220,7 +221,7 @@
// Start the child process.
if err := handle.Start(); err != nil {
vlog.Errorf("Start() failed: %v", err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
defer func() {
if err := handle.Clean(); err != nil {
@@ -230,40 +231,40 @@
// Wait for the child process to start.
if err := handle.WaitForReady(childReadyTimeout); err != nil {
vlog.Errorf("WaitForReady(%v) failed: %v", childReadyTimeout, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
childName, err := listener.waitForValue(childReadyTimeout)
if err != nil {
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
// Check that invoking Update() succeeds.
childName = naming.Join(childName, "nm")
nmClient := node.NodeClient(childName)
linkOld, pathOld, err := i.getCurrentFileInfo()
if err != nil {
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
// Since the resolution of mtime for files is seconds, the test sleeps
// for a second to make sure it can check whether the current symlink is
// updated.
time.Sleep(time.Second)
if err := nmClient.Revert(ctx); err != nil {
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
linkNew, pathNew, err := i.getCurrentFileInfo()
if err != nil {
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
// Check that the new node manager updated the current symbolic link.
if !linkOld.ModTime().Before(linkNew.ModTime()) {
vlog.Errorf("new node manager test failed")
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
// Ensure that the current symbolic link points to the same script.
if pathNew != pathOld {
updateLink(pathOld, i.config.CurrentLink)
vlog.Errorf("new node manager test failed")
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
return nil
}
@@ -276,7 +277,7 @@
path, err := filepath.EvalSymlinks(os.Args[0])
if err != nil {
vlog.Errorf("EvalSymlinks(%v) failed: %v", os.Args[0], err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
output := "#!/bin/bash\n"
@@ -292,31 +293,31 @@
path = filepath.Join(workspace, "noded.sh")
if err := ioutil.WriteFile(path, []byte(output), 0700); err != nil {
vlog.Errorf("WriteFile(%v) failed: %v", path, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
func (i *nodeService) updateNodeManager(ctx context.T) error {
if len(i.config.Origin) == 0 {
- return errUpdateNoOp
+ return verror2.Make(ErrUpdateNoOp, ctx)
}
envelope, err := fetchEnvelope(ctx, i.config.Origin)
if err != nil {
return err
}
if envelope.Title != application.NodeManagerTitle {
- return errIncompatibleUpdate
+ return verror2.Make(ErrAppTitleMismatch, ctx)
}
if i.config.Envelope != nil && reflect.DeepEqual(envelope, i.config.Envelope) {
- return errUpdateNoOp
+ return verror2.Make(ErrUpdateNoOp, ctx)
}
// Create new workspace.
workspace := filepath.Join(i.config.Root, "node-manager", generateVersionDirName())
perm := os.FileMode(0700)
if err := os.MkdirAll(workspace, perm); err != nil {
vlog.Errorf("MkdirAll(%v, %v) failed: %v", workspace, perm, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
deferrer := func() {
@@ -345,7 +346,7 @@
// Populate the new workspace with a node manager script.
configSettings, err := i.config.Save(envelope)
if err != nil {
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
if err := generateScript(workspace, configSettings, envelope); err != nil {
@@ -365,8 +366,8 @@
return nil
}
-func (*nodeService) Install(ipc.ServerContext, string) (string, error) {
- return "", errInvalidSuffix
+func (*nodeService) Install(ctx ipc.ServerContext, _ string) (string, error) {
+ return "", verror2.Make(ErrInvalidSuffix, ctx)
}
func (*nodeService) Refresh(ipc.ServerContext) error {
@@ -379,17 +380,17 @@
return nil
}
-func (*nodeService) Resume(ipc.ServerContext) error {
- return errInvalidSuffix
+func (*nodeService) Resume(ctx ipc.ServerContext) error {
+ return verror2.Make(ErrInvalidSuffix, ctx)
}
func (i *nodeService) Revert(call ipc.ServerContext) error {
if i.config.Previous == "" {
- return errUpdateNoOp
+ return verror2.Make(ErrUpdateNoOp, call)
}
updatingState := i.updating
if updatingState.testAndSetUpdating() {
- return errInProgress
+ return verror2.Make(ErrOperationInProgress, call)
}
err := i.revertNodeManager()
if err != nil {
@@ -398,12 +399,12 @@
return err
}
-func (*nodeService) Start(ipc.ServerContext) ([]string, error) {
- return nil, errInvalidSuffix
+func (*nodeService) Start(ctx ipc.ServerContext) ([]string, error) {
+ return nil, verror2.Make(ErrInvalidSuffix, ctx)
}
-func (*nodeService) Stop(ipc.ServerContext, uint32) error {
- return errInvalidSuffix
+func (*nodeService) Stop(ctx ipc.ServerContext, _ uint32) error {
+ return verror2.Make(ErrInvalidSuffix, ctx)
}
func (*nodeService) Suspend(ipc.ServerContext) error {
@@ -411,17 +412,17 @@
return nil
}
-func (*nodeService) Uninstall(ipc.ServerContext) error {
- return errInvalidSuffix
+func (*nodeService) Uninstall(ctx ipc.ServerContext) error {
+ return verror2.Make(ErrInvalidSuffix, ctx)
}
-func (i *nodeService) Update(ipc.ServerContext) error {
+func (i *nodeService) Update(call ipc.ServerContext) error {
ctx, cancel := rt.R().NewContext().WithTimeout(ipcContextTimeout)
defer cancel()
updatingState := i.updating
if updatingState.testAndSetUpdating() {
- return errInProgress
+ return verror2.Make(ErrOperationInProgress, call)
}
err := i.updateNodeManager(ctx)
@@ -444,13 +445,13 @@
return i.disp.getACL()
}
-func sameMachineCheck(call ipc.ServerContext) error {
- switch local, err := netstate.SameMachine(call.RemoteEndpoint().Addr()); {
+func sameMachineCheck(ctx ipc.ServerContext) error {
+ switch local, err := netstate.SameMachine(ctx.RemoteEndpoint().Addr()); {
case err != nil:
return err
case local == false:
vlog.Errorf("SameMachine() indicates that endpoint is not on the same node")
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, ctx)
}
return nil
}
diff --git a/services/mgmt/node/impl/util.go b/services/mgmt/node/impl/util.go
index 8446506..f700552 100644
--- a/services/mgmt/node/impl/util.go
+++ b/services/mgmt/node/impl/util.go
@@ -13,6 +13,7 @@
"veyron.io/veyron/veyron2/rt"
"veyron.io/veyron/veyron2/services/mgmt/application"
"veyron.io/veyron/veyron2/services/mgmt/repository"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
)
@@ -26,12 +27,12 @@
data, _, err := binary.Download(rt.R().NewContext(), name)
if err != nil {
vlog.Errorf("Download(%v) failed: %v", name, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
path, perm := filepath.Join(workspace, fileName), os.FileMode(755)
if err := ioutil.WriteFile(path, data, perm); err != nil {
vlog.Errorf("WriteFile(%v, %v) failed: %v", path, perm, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
@@ -44,7 +45,7 @@
envelope, err := stub.Match(ctx, profiles)
if err != nil {
vlog.Errorf("Match(%v) failed: %v", profiles, err)
- return nil, errOperationFailed
+ return nil, verror2.Make(ErrOperationFailed, ctx)
}
return &envelope, nil
}
@@ -55,7 +56,7 @@
self := os.Args[0]
if err := os.Link(self, path); err != nil {
vlog.Errorf("Link(%v, %v) failed: %v", self, path, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
@@ -70,16 +71,16 @@
if err == nil {
if err := os.Remove(fi.Name()); err != nil {
vlog.Errorf("Remove(%v) failed: %v", fi.Name(), err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
}
if err := os.Symlink(target, newLink); err != nil {
vlog.Errorf("Symlink(%v, %v) failed: %v", target, newLink, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
if err := os.Rename(newLink, link); err != nil {
vlog.Errorf("Rename(%v, %v) failed: %v", newLink, link, err)
- return errOperationFailed
+ return verror2.Make(ErrOperationFailed, nil)
}
return nil
}
diff --git a/services/mgmt/node/impl/util_test.go b/services/mgmt/node/impl/util_test.go
index ed1b555..52e1af6 100644
--- a/services/mgmt/node/impl/util_test.go
+++ b/services/mgmt/node/impl/util_test.go
@@ -19,6 +19,7 @@
"veyron.io/veyron/veyron2/security"
"veyron.io/veyron/veyron2/services/mgmt/node"
"veyron.io/veyron/veyron2/verror"
+ "veyron.io/veyron/veyron2/verror2"
"veyron.io/veyron/veyron2/vlog"
"veyron.io/veyron/veyron/lib/expect"
@@ -168,7 +169,7 @@
func resolveExpectNotFound(t *testing.T, name string) {
if results, err := rt.R().Namespace().Resolve(rt.R().NewContext(), name); err == nil {
t.Fatalf("Resolve(%v) succeeded with results %v when it was expected to fail", name, results)
- } else if expectErr := naming.ErrNoSuchName.ID; !verror.Is(err, expectErr) {
+ } else if expectErr := naming.ErrNoSuchName.ID; !verror2.Is(err, expectErr) {
t.Fatalf("Resolve(%v) failed with error %v, expected error ID %v", name, err, expectErr)
}
}
@@ -202,11 +203,7 @@
}
func updateNodeExpectError(t *testing.T, name string, errID verror.ID) {
- if err := nodeStub(name).Update(rt.R().NewContext()); !verror.Is(err, errID) {
- if errID == naming.ErrNoSuchName.ID && err.Error() == "no different version available" {
- // TODO(bprosnitz) Remove this check when errUpdateNoOp is updated to verror2
- return
- }
+ if err := nodeStub(name).Update(rt.R().NewContext()); !verror2.Is(err, errID) {
t.Fatalf("%s: Update(%v) expected to fail with %v, got %v instead", loc(1), name, errID, err)
}
}
@@ -218,11 +215,7 @@
}
func revertNodeExpectError(t *testing.T, name string, errID verror.ID) {
- if err := nodeStub(name).Revert(rt.R().NewContext()); !verror.Is(err, errID) {
- if errID == naming.ErrNoSuchName.ID && err.Error() == "no different version available" {
- // TODO(bprosnitz) Remove this check when errUpdateNoOp is updated to verror2
- return
- }
+ if err := nodeStub(name).Revert(rt.R().NewContext()); !verror2.Is(err, errID) {
t.Fatalf("%s: Revert(%v) expected to fail with %v, got %v instead", loc(1), name, errID, err)
}
}
@@ -292,7 +285,7 @@
}
func startAppExpectError(t *testing.T, appID string, expectedError verror.ID, opt ...veyron2.Runtime) {
- if _, err := startAppImpl(t, appID, "forapp", opt...); err == nil || !verror.Is(err, expectedError) {
+ if _, err := startAppImpl(t, appID, "forapp", opt...); err == nil || !verror2.Is(err, expectedError) {
t.Fatalf("%s: Start(%v) expected to fail with %v, got %v instead", loc(1), appID, expectedError, err)
}
}
@@ -316,7 +309,7 @@
}
func resumeAppExpectError(t *testing.T, appID, instanceID string, expectedError verror.ID, opt ...veyron2.Runtime) {
- if err := appStub(appID, instanceID).Resume(ort(opt).NewContext()); err == nil || !verror.Is(err, expectedError) {
+ if err := appStub(appID, instanceID).Resume(ort(opt).NewContext()); err == nil || !verror2.Is(err, expectedError) {
t.Fatalf("%s: Resume(%v/%v) expected to fail with %v, got %v instead", loc(1), appID, instanceID, expectedError, err)
}
}
@@ -328,11 +321,7 @@
}
func updateAppExpectError(t *testing.T, appID string, expectedError verror.ID) {
- if err := appStub(appID).Update(rt.R().NewContext()); err == nil || !verror.Is(err, expectedError) {
- if expectedError == naming.ErrNoSuchName.ID && err.Error() == "no different version available" {
- // TODO(bprosnitz) Remove this check when errUpdateNoOp is updated to verror2
- return
- }
+ if err := appStub(appID).Update(rt.R().NewContext()); err == nil || !verror2.Is(err, expectedError) {
t.Fatalf("%s: Update(%v) expected to fail with %v, got %v instead", loc(1), appID, expectedError, err)
}
}
@@ -344,11 +333,7 @@
}
func revertAppExpectError(t *testing.T, appID string, expectedError verror.ID) {
- if err := appStub(appID).Revert(rt.R().NewContext()); err == nil || !verror.Is(err, expectedError) {
- if expectedError == naming.ErrNoSuchName.ID && err.Error() == "no different version available" {
- // TODO(bprosnitz) Remove this check when errUpdateNoOp is updated to verror2
- return
- }
+ if err := appStub(appID).Revert(rt.R().NewContext()); err == nil || !verror2.Is(err, expectedError) {
t.Fatalf("%s: Revert(%v) expected to fail with %v, got %v instead", loc(1), appID, expectedError, err)
}
}
diff --git a/services/mgmt/profile/profile.vdl.go b/services/mgmt/profile/profile.vdl.go
index 97c0689..d3c766c 100644
--- a/services/mgmt/profile/profile.vdl.go
+++ b/services/mgmt/profile/profile.vdl.go
@@ -7,6 +7,9 @@
import (
"veyron.io/veyron/veyron2/services/mgmt/build"
+
+ // The non-user imports are prefixed with "__" to prevent collisions.
+ __vdl "veyron.io/veyron/veyron2/vdl"
)
// Library describes a shared library that applications may use.
@@ -19,6 +22,11 @@
MinorVersion string
}
+func (Library) __VDLReflect(struct {
+ Name string "veyron.io/veyron/veyron/services/mgmt/profile.Library"
+}) {
+}
+
// Specification is how we represent a profile internally. It should
// provide enough information to allow matching of binaries to nodes.
type Specification struct {
@@ -36,3 +44,13 @@
// OS is the target operating system of the profile.
OS build.OperatingSystem
}
+
+func (Specification) __VDLReflect(struct {
+ Name string "veyron.io/veyron/veyron/services/mgmt/profile.Specification"
+}) {
+}
+
+func init() {
+ __vdl.Register(Library{})
+ __vdl.Register(Specification{})
+}
diff --git a/services/mgmt/stats/impl/stats_test.go b/services/mgmt/stats/impl/stats_test.go
index 6b526f6..5555d2c 100644
--- a/services/mgmt/stats/impl/stats_test.go
+++ b/services/mgmt/stats/impl/stats_test.go
@@ -107,6 +107,8 @@
// Test WatchGlob()
{
+ noRM := types.ResumeMarker{}
+ _ = noRM
stream, err := c.WatchGlob(rt.R().NewContext(), types.GlobRequest{Pattern: "testing/foo/bar"})
if err != nil {
t.Fatalf("c.WatchGlob failed: %v", err)
@@ -116,6 +118,8 @@
t.Fatalf("expected more stream values")
}
got := iterator.Value()
+ // TODO(toddw): This change is necessary for vom2:
+ //expected := types.Change{Name: "testing/foo/bar", Value: int64(10), ResumeMarker: noRM}
expected := types.Change{Name: "testing/foo/bar", Value: int64(10)}
if !reflect.DeepEqual(got, expected) {
t.Errorf("unexpected result. Got %#v, want %#v", got, expected)
@@ -127,6 +131,8 @@
t.Fatalf("expected more stream values")
}
got = iterator.Value()
+ // TODO(toddw): This change is necessary for vom2:
+ //expected := types.Change{Name: "testing/foo/bar", Value: int64(15), ResumeMarker: noRM}
expected = types.Change{Name: "testing/foo/bar", Value: int64(15)}
if !reflect.DeepEqual(got, expected) {
t.Errorf("unexpected result. Got %#v, want %#v", got, expected)
@@ -138,6 +144,8 @@
t.Fatalf("expected more stream values")
}
got = iterator.Value()
+ // TODO(toddw): This change is necessary for vom2:
+ //expected := types.Change{Name: "testing/foo/bar", Value: int64(17), ResumeMarker: noRM}
expected = types.Change{Name: "testing/foo/bar", Value: int64(17)}
if !reflect.DeepEqual(got, expected) {
t.Errorf("unexpected result. Got %#v, want %#v", got, expected)
diff --git a/services/mgmt/stats/types.vdl.go b/services/mgmt/stats/types.vdl.go
index 7ad330c..cc41c75 100644
--- a/services/mgmt/stats/types.vdl.go
+++ b/services/mgmt/stats/types.vdl.go
@@ -4,6 +4,11 @@
// Packages stats defines the non-native types exported by the stats service.
package stats
+import (
+ // The non-user imports are prefixed with "__" to prevent collisions.
+ __vdl "veyron.io/veyron/veyron2/vdl"
+)
+
// HistogramValue is the value of Histogram objects.
type HistogramValue struct {
// Count is the total number of values added to the histogram.
@@ -14,6 +19,11 @@
Buckets []HistogramBucket
}
+func (HistogramValue) __VDLReflect(struct {
+ Name string "veyron.io/veyron/veyron/services/mgmt/stats.HistogramValue"
+}) {
+}
+
// HistogramBucket is one histogram bucket.
type HistogramBucket struct {
// LowBound is the lower bound of the bucket.
@@ -21,3 +31,13 @@
// Count is the number of values in the bucket.
Count int64
}
+
+func (HistogramBucket) __VDLReflect(struct {
+ Name string "veyron.io/veyron/veyron/services/mgmt/stats.HistogramBucket"
+}) {
+}
+
+func init() {
+ __vdl.Register(HistogramValue{})
+ __vdl.Register(HistogramBucket{})
+}
diff --git a/tools/debug/impl.go b/tools/debug/impl.go
index f201b5d..e36d950 100644
--- a/tools/debug/impl.go
+++ b/tools/debug/impl.go
@@ -27,7 +27,7 @@
"veyron.io/veyron/veyron2/services/watch"
watchtypes "veyron.io/veyron/veyron2/services/watch/types"
"veyron.io/veyron/veyron2/uniqueid"
- "veyron.io/veyron/veyron2/vom"
+ "veyron.io/veyron/veyron2/vdl/vdlutil"
"veyron.io/veyron/veyron2/vtrace"
)
@@ -42,7 +42,7 @@
)
func init() {
- vom.Register(istats.HistogramValue{})
+ vdlutil.Register(istats.HistogramValue{})
// logs read flags
cmdLogsRead.Flags.BoolVar(&follow, "f", false, "When true, read will wait for new log entries when it reaches the end of the file.")
diff --git a/tools/mgmt/nodex/acl_test.go b/tools/mgmt/nodex/acl_test.go
index 1b2a332..25aec7e 100644
--- a/tools/mgmt/nodex/acl_test.go
+++ b/tools/mgmt/nodex/acl_test.go
@@ -4,6 +4,7 @@
"bytes"
"fmt"
"reflect"
+ "regexp"
"strings"
"testing"
@@ -226,8 +227,8 @@
if err := cmd.Execute([]string{"acl", "set", nodeName, "vana/bad", "Read"}); err == nil {
t.Fatalf("GetACL RPC inside acl set command failed but error wrongly not detected")
}
- if expected, got := "ERROR: GetACL("+nodeName+") failed: oops!", strings.TrimSpace(stderr.String()); !strings.HasPrefix(got, expected) {
- t.Fatalf("Unexpected output from list. Got %q, prefix %q", got, expected)
+ if expected, got := `^ERROR: GetACL\(`+nodeName+`\) failed:.*oops!`, strings.TrimSpace(stderr.String()); !regexp.MustCompile(expected).MatchString(got) {
+ t.Fatalf("Unexpected output from list. Got %q, regexp %q", got, expected)
}
if expected, got := "", strings.TrimSpace(stdout.String()); got != expected {
t.Fatalf("Unexpected output from list. Got %q, expected %q", got, expected)
@@ -262,8 +263,8 @@
if expected, got := "", strings.TrimSpace(stdout.String()); got != expected {
t.Fatalf("Unexpected output from list. Got %q, expected %q", got, expected)
}
- if expected, got := "ERROR: SetACL("+nodeName+") failed: oops!", strings.TrimSpace(stderr.String()); !strings.HasPrefix(got, expected) {
- t.Fatalf("Unexpected output from list. Got %q, prefix %q", got, expected)
+ if expected, got := `^ERROR: SetACL\(`+nodeName+`\) failed:.*oops!`, strings.TrimSpace(stderr.String()); !regexp.MustCompile(expected).MatchString(got) {
+ t.Fatalf("Unexpected output from list. Got %q, regexp %q", got, expected)
}
expected = []interface{}{
diff --git a/tools/vrpc/impl.go b/tools/vrpc/impl.go
index 4a87c67..3133ea4 100644
--- a/tools/vrpc/impl.go
+++ b/tools/vrpc/impl.go
@@ -121,15 +121,15 @@
// Benj implements support for decoding arbitrary structs to an
// empty interface, this will no longer be needed.
var x1 idl_test_base.Struct
- vom.Register(x1)
+ vdlutil.Register(x1)
var x2 idl_node.Description
- vom.Register(x2)
+ vdlutil.Register(x2)
var x3 idl_binary.Description
- vom.Register(x3)
+ vdlutil.Register(x3)
var x4 naming.VDLMountedServer
- vom.Register(x4)
+ vdlutil.Register(x4)
var x5 naming.VDLMountEntry
- vom.Register(x5)
+ vdlutil.Register(x5)
// Decode the inputs from vomJSON-formatted command-line arguments.
inputs := make([]interface{}, len(args))
diff --git a/tools/vrpc/test_base/test_base.vdl.go b/tools/vrpc/test_base/test_base.vdl.go
index eec0c49..a411da3 100644
--- a/tools/vrpc/test_base/test_base.vdl.go
+++ b/tools/vrpc/test_base/test_base.vdl.go
@@ -9,6 +9,7 @@
__veyron2 "veyron.io/veyron/veyron2"
__context "veyron.io/veyron/veyron2/context"
__ipc "veyron.io/veyron/veyron2/ipc"
+ __vdl "veyron.io/veyron/veyron2/vdl"
__vdlutil "veyron.io/veyron/veyron2/vdl/vdlutil"
__wiretype "veyron.io/veyron/veyron2/wiretype"
)
@@ -23,6 +24,15 @@
Y int32
}
+func (Struct) __VDLReflect(struct {
+ Name string "veyron.io/veyron/veyron/tools/vrpc/test_base.Struct"
+}) {
+}
+
+func init() {
+ __vdl.Register(Struct{})
+}
+
// TypeTesterClientMethods is the client interface
// containing TypeTester methods.
type TypeTesterClientMethods interface {
