vom: move magicbyte handling into encode/decode.
* move magicbyte handling into encode/decode and change
New{Encoder,Decoder} API to no return error any more.
MultiPart: 2/3
Change-Id: I9ceef311128c4b422494d4cd7929bfc1e420508f
diff --git a/cmd/principal/main.go b/cmd/principal/main.go
index c569599..2c76e3a 100644
--- a/cmd/principal/main.go
+++ b/cmd/principal/main.go
@@ -1141,10 +1141,7 @@
func base64VomEncode(i interface{}) (string, error) {
buf := &bytes.Buffer{}
closer := base64.NewEncoder(base64.URLEncoding, buf)
- enc, err := vom.NewEncoder(closer)
- if err != nil {
- return "", err
- }
+ enc := vom.NewEncoder(closer)
if err := enc.Encode(i); err != nil {
return "", err
}
@@ -1161,10 +1158,7 @@
if err != nil {
return err
}
- dec, err := vom.NewDecoder(bytes.NewBuffer(b))
- if err != nil {
- return err
- }
+ dec := vom.NewDecoder(bytes.NewBuffer(b))
return dec.Decode(i)
}
diff --git a/cmd/vom/vom.go b/cmd/vom/vom.go
index 58d4fdc..d8d82a0 100644
--- a/cmd/vom/vom.go
+++ b/cmd/vom/vom.go
@@ -124,10 +124,7 @@
reader := bytes.NewBuffer(binbytes)
// Decode the binary bytes.
// TODO(toddw): Add a flag to set a specific type to decode into.
- decoder, err := vom.NewDecoder(reader)
- if err != nil {
- return err
- }
+ decoder := vom.NewDecoder(reader)
var result *vdl.Value
if err := decoder.Decode(&result); err != nil {
return err
diff --git a/cmd/vomtestgen/generate.go b/cmd/vomtestgen/generate.go
index c4b67f9..e6382b3 100644
--- a/cmd/vomtestgen/generate.go
+++ b/cmd/vomtestgen/generate.go
@@ -201,7 +201,7 @@
Value any // Value to test
TypeString string // The string representation of the Type
Hex string // Hex pattern representing vom encoding
- HexMagic string // Hex pattern representing vom encoding of MagicByte
+ HexVersion string // Hex pattern representing vom encoding of Version
HexType string // Hex pattern representing vom encoding of Type
HexValue string // Hex pattern representing vom encoding of Value
}
@@ -222,7 +222,7 @@
value = value.Elem()
}
valstr := vdlgen.TypedConst(value, testpkg, imports)
- hexmagic, hextype, hexvalue, vomdump, err := toVomHex(value)
+ hexversion, hextype, hexvalue, vomdump, err := toVomHex(value)
if err != nil {
return nil, err
}
@@ -234,7 +234,7 @@
%[2]q,
%[3]q,
%[4]q, %[5]q, %[6]q,
- },`, valstr, value.Type().String(), hexmagic+hextype+hexvalue, hexmagic, hextype, hexvalue, vomdump)
+ },`, valstr, value.Type().String(), hexversion+hextype+hexvalue, hexversion, hextype, hexvalue, vomdump)
}
fmt.Fprintf(buf, `
}
@@ -318,27 +318,22 @@
func toVomHex(value *vdl.Value) (string, string, string, string, error) {
var buf, typebuf bytes.Buffer
- typeenc, err := vom.NewTypeEncoder(&typebuf)
- if err != nil {
- return "", "", "", "", fmt.Errorf("vom.NewTypeEncoder failed: %v", err)
- }
- encoder, err := vom.NewEncoderWithTypeEncoder(&buf, typeenc)
- if err != nil {
- return "", "", "", "", fmt.Errorf("vom.NewEncoderWithTypeEncoder failed: %v", err)
- }
+ encoder := vom.NewEncoderWithTypeEncoder(&buf, vom.NewTypeEncoder(&typebuf))
if err := encoder.Encode(value); err != nil {
return "", "", "", "", fmt.Errorf("vom.Encode(%v) failed: %v", value, err)
}
- magic, _ := buf.ReadByte() // Read the magic byte.
- vombytes := append(typebuf.Bytes(), buf.Bytes()...)
- typebuf.ReadByte() // Remove the magic byte.
+ version, _ := buf.ReadByte() // Read the version byte.
+ if typebuf.Len() > 0 {
+ typebuf.ReadByte() // Remove the version byte.
+ }
+ vombytes := append(append([]byte{version}, typebuf.Bytes()...), buf.Bytes()...)
const pre = "\t// "
vomdump := pre + strings.Replace(vom.Dump(vombytes), "\n", "\n"+pre, -1)
if strings.HasSuffix(vomdump, "\n"+pre) {
vomdump = vomdump[:len(vomdump)-len("\n"+pre)]
}
// TODO(toddw): Add hex pattern bracketing for map and set.
- return fmt.Sprintf("%x", magic), fmt.Sprintf("%x", typebuf.Bytes()), fmt.Sprintf("%x", buf.Bytes()), vomdump, nil
+ return fmt.Sprintf("%x", version), fmt.Sprintf("%x", typebuf.Bytes()), fmt.Sprintf("%x", buf.Bytes()), vomdump, nil
}
func writeFile(data []byte, outName string) error {
diff --git a/lib/security/serialization/signing_writer.go b/lib/security/serialization/signing_writer.go
index 840f6cb..93245d7 100644
--- a/lib/security/serialization/signing_writer.go
+++ b/lib/security/serialization/signing_writer.go
@@ -17,9 +17,8 @@
)
var (
- errCantBeNilSigner = verror.Register(pkgPath+".errCantBeNilSigner", verror.NoRetry, "{1:}{2:} data:{3} signature:{4} signer:{5} cannot be nil{:_}")
- errCantCreateEncoder = verror.Register(pkgPath+".errCantCreateEncoder", verror.NoRetry, "{1:}{2:} failed to create new encoder{:_}")
- errCantSign = verror.Register(pkgPath+".errCantSign", verror.NoRetry, "{1:}{2:} signing failed{:_}")
+ errCantBeNilSigner = verror.Register(pkgPath+".errCantBeNilSigner", verror.NoRetry, "{1:}{2:} data:{3} signature:{4} signer:{5} cannot be nil{:_}")
+ errCantSign = verror.Register(pkgPath+".errCantSign", verror.NoRetry, "{1:}{2:} signing failed{:_}")
)
const defaultChunkSizeBytes = 1 << 20
@@ -98,10 +97,7 @@
if (data == nil) || (signature == nil) || (s == nil) {
return nil, verror.New(errCantBeNilSigner, nil, data, signature, s)
}
- enc, err := vom.NewEncoder(signature)
- if err != nil {
- return nil, verror.New(errCantCreateEncoder, nil, err)
- }
+ enc := vom.NewEncoder(signature)
w := &signingWriter{data: data, signature: signature, signer: s, signatureHash: sha256.New(), chunkSizeBytes: defaultChunkSizeBytes, sigEnc: enc}
if opts != nil {
diff --git a/lib/security/serialization/verifying_reader.go b/lib/security/serialization/verifying_reader.go
index 28c736a..5427009 100644
--- a/lib/security/serialization/verifying_reader.go
+++ b/lib/security/serialization/verifying_reader.go
@@ -21,7 +21,6 @@
var (
errCantBeNilVerifier = verror.Register(pkgPath+".errCantBeNilVerifier", verror.NoRetry, "{1:}{2:} data:{3} signature:{4} key:{5} cannot be nil{:_}")
errModifiedSinceWritten = verror.Register(pkgPath+".errModifiedSinceWritten", verror.NoRetry, "{1:}{2:} data has been modified since being written{:_}")
- errCantCreateDecoder = verror.Register(pkgPath+".errCantCreateDecoder", verror.NoRetry, "{1:}{2:} failed to create new decoder{:_}")
errCantDecodeHeader = verror.Register(pkgPath+".errCantDecodeHeader", verror.NoRetry, "{1:}{2:} failed to decode header{:_}")
errCantVerifySig = verror.Register(pkgPath+".errCantVerifySig", verror.NoRetry, "{1:}{2:} signature verification failed{:_}")
errBadTypeFromSigReader = verror.Register(pkgPath+".errBadTypeFromSigReader", verror.NoRetry, "{1:}{2:} invalid data of type: {3} read from signature Reader{:_}")
@@ -93,10 +92,7 @@
func (r *verifyingReader) verifySignature(signature io.Reader, key security.PublicKey) error {
signatureHash := sha256.New()
- dec, err := vom.NewDecoder(signature)
- if err != nil {
- return verror.New(errCantCreateDecoder, nil, err)
- }
+ dec := vom.NewDecoder(signature)
var h SignedHeader
if err := dec.Decode(&h); err != nil {
return verror.New(errCantDecodeHeader, nil, err)
diff --git a/lib/security/storage.go b/lib/security/storage.go
index 1690c91..07058f3 100644
--- a/lib/security/storage.go
+++ b/lib/security/storage.go
@@ -25,11 +25,7 @@
if err != nil {
return err
}
- enc, err := vom.NewEncoder(swc)
- if err != nil {
- swc.Close()
- return err
- }
+ enc := vom.NewEncoder(swc)
if err := enc.Encode(obj); err != nil {
swc.Close()
return err
@@ -47,9 +43,6 @@
if err != nil {
return err
}
- dec, err := vom.NewDecoder(vr)
- if err != nil {
- return err
- }
+ dec := vom.NewDecoder(vr)
return dec.Decode(obj)
}
diff --git a/profiles/internal/rpc/client.go b/profiles/internal/rpc/client.go
index 6ba7074..2efc1b3 100644
--- a/profiles/internal/rpc/client.go
+++ b/profiles/internal/rpc/client.go
@@ -52,8 +52,6 @@
errNonRootedName = reg(".errNonRootedName", "{3} does not appear to contain an address")
errInvalidEndpoint = reg(".errInvalidEndpoint", "failed to parse endpoint")
errIncompatibleEndpoint = reg(".errIncompatibleEndpoint", "incompatible endpoint")
- errVomEncoder = reg(".errVomEncoder", "failed to create vom encoder{:3}")
- errVomDecoder = reg(".errVomDecoder", "failed to create vom decoder{:3}")
errRequestEncoding = reg(".errRequestEncoding", "failed to encode request {3}{:4}")
errDischargeEncoding = reg(".errDischargeEncoding", "failed to encode discharges {:3}")
errBlessingEncoding = reg(".errBlessingEncoding", "failed to encode blessing {3}{:4}")
@@ -785,30 +783,14 @@
server: server,
dc: dc,
}
- var err error
typeenc := flow.VCDataCache().Get(vc.TypeEncoderKey{})
if typeenc == nil {
- if fc.enc, err = vom.NewEncoder(flow); err != nil {
- // In practice, this will never fail because of a networking
- // problem since the encoder writes the 'magic byte' which
- // will be buffered and not written to the network immediately.
- berr := verror.AddSubErrs(verror.New(errVomEncoder, fc.ctx), fc.ctx, verror.SubErr{Err: err})
- return nil, fc.close(berr)
- }
- if fc.dec, err = vom.NewDecoder(flow); err != nil {
- berr := verror.AddSubErrs(verror.New(errVomDecoder, fc.ctx), fc.ctx, verror.SubErr{Err: err})
- return nil, fc.close(berr)
- }
+ fc.enc = vom.NewEncoder(flow)
+ fc.dec = vom.NewDecoder(flow)
} else {
- if fc.enc, err = vom.NewEncoderWithTypeEncoder(flow, typeenc.(*vom.TypeEncoder)); err != nil {
- berr := verror.AddSubErrs(verror.New(errVomEncoder, fc.ctx), fc.ctx, verror.SubErr{Err: err})
- return nil, fc.close(berr)
- }
+ fc.enc = vom.NewEncoderWithTypeEncoder(flow, typeenc.(*vom.TypeEncoder))
typedec := flow.VCDataCache().Get(vc.TypeDecoderKey{})
- if fc.dec, err = vom.NewDecoderWithTypeDecoder(flow, typedec.(*vom.TypeDecoder)); err != nil {
- berr := verror.AddSubErrs(verror.New(errVomDecoder, fc.ctx), fc.ctx, verror.SubErr{Err: err})
- return nil, fc.close(berr)
- }
+ fc.dec = vom.NewDecoderWithTypeDecoder(flow, typedec.(*vom.TypeDecoder))
}
return fc, nil
}
@@ -850,7 +832,7 @@
}
}
switch verror.ErrorID(err) {
- case errVomDecoder.ID, errVomEncoder.ID, errRequestEncoding.ID, errArgEncoding.ID, errResponseDecoding.ID:
+ case errRequestEncoding.ID, errArgEncoding.ID, errResponseDecoding.ID:
return verror.New(verror.ErrBadProtocol, fc.ctx, err)
}
return err
@@ -874,7 +856,7 @@
Language: string(i18n.GetLangID(fc.ctx)),
}
if err := fc.enc.Encode(req); err != nil {
- berr := verror.New(errRequestEncoding, fc.ctx, fmt.Sprintf("%#v", req), err)
+ berr := verror.New(verror.ErrBadProtocol, fc.ctx, verror.New(errRequestEncoding, fc.ctx, fmt.Sprintf("%#v", req), err))
return fc.close(berr)
}
for ix, arg := range args {
diff --git a/profiles/internal/rpc/server.go b/profiles/internal/rpc/server.go
index 95ebf68..a715691 100644
--- a/profiles/internal/rpc/server.go
+++ b/profiles/internal/rpc/server.go
@@ -965,27 +965,14 @@
flow: flow,
discharges: make(map[string]security.Discharge),
}
- var err error
typeenc := flow.VCDataCache().Get(vc.TypeEncoderKey{})
if typeenc == nil {
- if fs.enc, err = vom.NewEncoder(flow); err != nil {
- flow.Close()
- return nil, err
- }
- if fs.dec, err = vom.NewDecoder(flow); err != nil {
- flow.Close()
- return nil, err
- }
+ fs.enc = vom.NewEncoder(flow)
+ fs.dec = vom.NewDecoder(flow)
} else {
- if fs.enc, err = vom.NewEncoderWithTypeEncoder(flow, typeenc.(*vom.TypeEncoder)); err != nil {
- flow.Close()
- return nil, err
- }
+ fs.enc = vom.NewEncoderWithTypeEncoder(flow, typeenc.(*vom.TypeEncoder))
typedec := flow.VCDataCache().Get(vc.TypeDecoderKey{})
- if fs.dec, err = vom.NewDecoderWithTypeDecoder(flow, typedec.(*vom.TypeDecoder)); err != nil {
- flow.Close()
- return nil, err
- }
+ fs.dec = vom.NewDecoderWithTypeDecoder(flow, typedec.(*vom.TypeDecoder))
}
return fs, nil
}
diff --git a/profiles/internal/rpc/server_test.go b/profiles/internal/rpc/server_test.go
index 900db9a..a5d1b7d 100644
--- a/profiles/internal/rpc/server_test.go
+++ b/profiles/internal/rpc/server_test.go
@@ -131,7 +131,8 @@
type statusServer struct{ ch chan struct{} }
func (s *statusServer) Hang(*context.T, rpc.ServerCall) error {
- <-s.ch
+ s.ch <- struct{}{} // Notify the server has received a call.
+ <-s.ch // Wait for the server to be ready to go.
return nil
}
@@ -178,10 +179,11 @@
}
go makeCall(ctx)
- // Wait for RPC to start
+ // Wait for RPC to start and the server has received the call.
if err := <-progress; err != nil {
t.Fatalf(err.Error())
}
+ <-serverChan
// Stop server asynchronously
go func() {
diff --git a/profiles/internal/rpc/stream/manager/listener.go b/profiles/internal/rpc/stream/manager/listener.go
index 2af4149..869e50f 100644
--- a/profiles/internal/rpc/stream/manager/listener.go
+++ b/profiles/internal/rpc/stream/manager/listener.go
@@ -46,8 +46,6 @@
// level errors and hence {1}{2} is omitted from their format
// strings to avoid repeating these n-times in the final error
// message visible to the user.
- errVomEncoder = reg(".errVomEncoder", "failed to create vom encoder{:3}")
- errVomDecoder = reg(".errVomDecoder", "failed to create vom decoder{:3}")
errVomEncodeRequest = reg(".errVomEncodeRequest", "failed to encode request to proxy{:3}")
errVomDecodeResponse = reg(".errVomDecodeRequest", "failed to decoded response from proxy{:3}")
errProxyError = reg(".errProxyError", "proxy error {:3}")
@@ -346,23 +344,13 @@
return nil, nil, verror.New(stream.ErrSecurity, nil, verror.New(errRefusedProxyLogin, nil, err))
}
}
- enc, err := vom.NewEncoder(flow)
- if err != nil {
- flow.Close()
- vf.StopAccepting()
- return nil, nil, verror.New(stream.ErrNetwork, nil, verror.New(errVomDecoder, nil, err))
- }
+ enc := vom.NewEncoder(flow)
if err := enc.Encode(request); err != nil {
flow.Close()
vf.StopAccepting()
return nil, nil, verror.New(stream.ErrNetwork, nil, verror.New(errVomEncodeRequest, nil, err))
}
- dec, err := vom.NewDecoder(flow)
- if err != nil {
- flow.Close()
- vf.StopAccepting()
- return nil, nil, verror.New(stream.ErrNetwork, nil, verror.New(errVomDecoder, nil, err))
- }
+ dec := vom.NewDecoder(flow)
if err := dec.Decode(&response); err != nil {
flow.Close()
vf.StopAccepting()
diff --git a/profiles/internal/rpc/stream/proxy/proxy.go b/profiles/internal/rpc/stream/proxy/proxy.go
index 414b759..1022b10 100644
--- a/profiles/internal/rpc/stream/proxy/proxy.go
+++ b/profiles/internal/rpc/stream/proxy/proxy.go
@@ -53,8 +53,6 @@
errNoRoutingTableEntry = reg(".errNoRoutingTableEntry", "routing table has no entry for the VC")
errProcessVanished = reg(".errProcessVanished", "remote process vanished")
errDuplicateSetupVC = reg(".errDuplicateSetupVC", "duplicate SetupVC request")
- errVomDecoder = reg(".errVomDecoder", "failed to create vom decoder{:3}")
- errVomEncoder = reg(".errVomEncoder", "failed to create vom encoder{:3}")
errVomEncodeResponse = reg(".errVomEncodeResponse", "failed to encode response from proxy{:3}")
errNoRequest = reg(".errNoRequest", "unable to read Request{:3}")
errServerClosedByProxy = reg(".errServerClosedByProxy", "server closed by proxy")
@@ -343,10 +341,8 @@
server.Process.InitVCI(server.VC.VCI())
var request Request
var response Response
- dec, err := vom.NewDecoder(conn)
- if err != nil {
- response.Error = verror.New(stream.ErrProxy, nil, verror.New(errVomDecoder, nil, err))
- } else if err := dec.Decode(&request); err != nil {
+ dec := vom.NewDecoder(conn)
+ if err := dec.Decode(&request); err != nil {
response.Error = verror.New(stream.ErrProxy, nil, verror.New(errNoRequest, nil, err))
} else if err := p.authorize(server.VC, request); err != nil {
response.Error = err
@@ -362,12 +358,7 @@
}
response.Endpoint = ep.String()
}
- enc, err := vom.NewEncoder(conn)
- if err != nil {
- proxyLog().Infof("Failed to create Encoder for server %v: %v", server, err)
- server.Close(verror.New(stream.ErrProxy, nil, verror.New(errVomEncoder, nil, err)))
- return
- }
+ enc := vom.NewEncoder(conn)
if err := enc.Encode(response); err != nil {
proxyLog().Infof("Failed to encode response %#v for server %v", response, server)
server.Close(verror.New(stream.ErrProxy, nil, verror.New(errVomEncodeResponse, nil, err)))
diff --git a/profiles/internal/rpc/stream/vc/auth.go b/profiles/internal/rpc/stream/vc/auth.go
index e19d10f..ade2e49 100644
--- a/profiles/internal/rpc/stream/vc/auth.go
+++ b/profiles/internal/rpc/stream/vc/auth.go
@@ -28,8 +28,6 @@
// level errors and hence {1}{2} is omitted from their format
// strings to avoid repeating these n-times in the final error
// message visible to the user.
- errVomDecoder = reg(".errVomDecoder", "failed to create vom decoder{:3}")
- errVomEncoder = reg(".errVomEncoder", "failed to create vom encoder{:3}")
errVomEncodeBlessing = reg(".errVomEncodeRequest", "failed to encode blessing{:3}")
errHandshakeMessage = reg(".errHandshakeMessage", "failed to read hanshake message{:3}")
errInvalidSignatureInMessage = reg(".errInvalidSignatureInMessage", "signature does not verify in authentication handshake message")
@@ -100,10 +98,7 @@
return err
}
var buf bytes.Buffer
- enc, err := vom.NewEncoder(&buf)
- if err != nil {
- return verror.New(stream.ErrNetwork, nil, verror.New(errVomEncoder, nil, err))
- }
+ enc := vom.NewEncoder(&buf)
if err := enc.Encode(signature); err != nil {
return verror.New(stream.ErrNetwork, nil, verror.New(errVomEncodeBlessing, nil, err))
}
@@ -118,10 +113,7 @@
return err
}
defer msg.Release()
- enc, err = vom.NewEncoder(w)
- if err != nil {
- return verror.New(stream.ErrNetwork, nil, verror.New(errVomEncoder, nil, err))
- }
+ enc = vom.NewEncoder(w)
if err := enc.Encode(msg.Contents); err != nil {
return verror.New(stream.ErrNetwork, nil, verror.New(errVomEncodeBlessing, nil, err))
}
@@ -131,10 +123,7 @@
func readBlessings(r io.Reader, tag []byte, crypter crypto.Crypter, v version.RPCVersion) (security.Blessings, map[string]security.Discharge, error) {
var msg []byte
var noBlessings security.Blessings
- dec, err := vom.NewDecoder(r)
- if err != nil {
- return noBlessings, nil, verror.New(stream.ErrNetwork, nil, verror.New(errVomDecoder, nil, err))
- }
+ dec := vom.NewDecoder(r)
if err := dec.Decode(&msg); err != nil {
return noBlessings, nil, verror.New(stream.ErrNetwork, nil, verror.New(errHandshakeMessage, nil, err))
}
@@ -143,11 +132,7 @@
return noBlessings, nil, err
}
defer buf.Release()
- dec, err = vom.NewDecoder(bytes.NewReader(buf.Contents))
- if err != nil {
- return noBlessings, nil, verror.New(stream.ErrNetwork, nil, verror.New(errVomDecoder, nil, err))
- }
-
+ dec = vom.NewDecoder(bytes.NewReader(buf.Contents))
var (
blessings security.Blessings
sig security.Signature
diff --git a/profiles/internal/rpc/stream/vc/vc.go b/profiles/internal/rpc/stream/vc/vc.go
index 7a8a567..7846d4e 100644
--- a/profiles/internal/rpc/stream/vc/vc.go
+++ b/profiles/internal/rpc/stream/vc/vc.go
@@ -52,8 +52,6 @@
errClosedDuringHandshake = reg(".errCloseDuringHandshake", "VC closed during handshake{:3}")
errFailedToDecryptPayload = reg(".errFailedToDecryptPayload", "failed to decrypt payload{:3}")
errIgnoringMessageOnClosedVC = reg(".errIgnoringMessageOnClosedVC", "ignoring message for Flow {3} on closed VC {4}")
- errVomTypeDecoder = reg(".errVomDecoder", "failed to create vom type decoder{:3}")
- errVomTypeEncoder = reg(".errVomEncoder", "failed to create vom type encoder{:3}")
errFailedToCreateFlowForAuth = reg(".errFailedToCreateFlowForAuth", "failed to create a Flow for authentication{:3}")
errAuthFlowNotAccepted = reg(".errAuthFlowNotAccepted", "authentication Flow not accepted{:3}")
errFailedToCreateFlowForWireType = reg(".errFailedToCreateFlowForWireType", "fail to create a Flow for wire type{:3}")
@@ -702,11 +700,7 @@
if dc == nil {
return
}
- enc, err := vom.NewEncoder(conn)
- if err != nil {
- vlog.Errorf("failed to create new encoder for discharges on VC %v: %v", vc, err)
- return
- }
+ enc := vom.NewEncoder(conn)
discharges := dc.PrepareDischarges(nil, tpCavs, security.DischargeImpetus{})
for expiry := minExpiryTime(discharges, tpCavs); !expiry.IsZero(); expiry = minExpiryTime(discharges, tpCavs) {
select {
@@ -756,12 +750,7 @@
func (vc *VC) recvDischargesLoop(conn io.ReadCloser) {
defer conn.Close()
- dec, err := vom.NewDecoder(conn)
- if err != nil {
- vlog.Errorf("failed to create new decoder for discharges on %v: %v", vc, err)
- return
- }
-
+ dec := vom.NewDecoder(conn)
for {
var discharges []security.Discharge
if err := dec.Decode(&discharges); err != nil {
@@ -787,18 +776,8 @@
if err != nil {
return verror.New(stream.ErrSecurity, nil, verror.New(errFailedToCreateFlowForWireType, nil, err))
}
- typeEnc, err := vom.NewTypeEncoder(conn)
- if err != nil {
- conn.Close()
- return verror.New(stream.ErrSecurity, nil, verror.New(errVomTypeEncoder, nil, err))
- }
- vc.dataCache.Insert(TypeEncoderKey{}, typeEnc)
- typeDec, err := vom.NewTypeDecoder(conn)
- if err != nil {
- conn.Close()
- return verror.New(stream.ErrSecurity, nil, verror.New(errVomTypeDecoder, nil, err))
- }
- vc.dataCache.Insert(TypeDecoderKey{}, typeDec)
+ vc.dataCache.Insert(TypeEncoderKey{}, vom.NewTypeEncoder(conn))
+ vc.dataCache.Insert(TypeDecoderKey{}, vom.NewTypeDecoder(conn))
if vc.Version() < version.RPCVersion10 {
return nil
@@ -823,18 +802,8 @@
if err != nil {
return verror.New(errFlowForWireTypeNotAccepted, nil, err)
}
- typeEnc, err := vom.NewTypeEncoder(conn)
- if err != nil {
- conn.Close()
- return verror.New(errVomTypeEncoder, nil, err)
- }
- vc.dataCache.Insert(TypeEncoderKey{}, typeEnc)
- typeDec, err := vom.NewTypeDecoder(conn)
- if err != nil {
- conn.Close()
- return verror.New(errVomTypeDecoder, nil, err)
- }
- vc.dataCache.Insert(TypeDecoderKey{}, typeDec)
+ vc.dataCache.Insert(TypeEncoderKey{}, vom.NewTypeEncoder(conn))
+ vc.dataCache.Insert(TypeDecoderKey{}, vom.NewTypeDecoder(conn))
if vc.Version() < version.RPCVersion10 {
return nil
diff --git a/profiles/internal/rpc/test/client_test.go b/profiles/internal/rpc/test/client_test.go
index 961384a..04a77db 100644
--- a/profiles/internal/rpc/test/client_test.go
+++ b/profiles/internal/rpc/test/client_test.go
@@ -398,8 +398,8 @@
func dropDataDialer(network, address string, timeout time.Duration) (net.Conn, error) {
matcher := func(read bool, msg message.T) bool {
- switch msg.(type) {
- case *message.Data:
+ // Drop and close the connection when reading the first data message.
+ if _, ok := msg.(*message.Data); ok && read {
return true
}
return false
@@ -440,7 +440,7 @@
nctx, _ := context.WithTimeout(ctx, time.Minute)
call, err := client.StartCall(nctx, "name", "noname", nil, options.NoRetry{}, options.SecurityNone)
- if verror.ErrorID(err) != verror.ErrBadProtocol.ID {
+ if verror.ErrorID(err) != verror.ErrNoServers.ID {
t.Fatalf("wrong error: %s", err)
}
if call != nil {
diff --git a/services/internal/fs/simplestore.go b/services/internal/fs/simplestore.go
index eca4974..8ae5457 100644
--- a/services/internal/fs/simplestore.go
+++ b/services/internal/fs/simplestore.go
@@ -254,10 +254,7 @@
return nil, verror.New(errFileSystemError, nil, err)
}
- decoder, err := vom.NewDecoder(file)
- if err != nil {
- return nil, verror.New(errDecodeFailedBadData, nil, err)
- }
+ decoder := vom.NewDecoder(file)
if err := decoder.Decode(&data); err != nil {
return nil, verror.New(errDecodeFailedBadData, nil, err)
}
@@ -563,11 +560,7 @@
if _, err := file.Write([]byte{byte(vomGobMagicByte)}); err != nil {
return err
}
- enc, err := vom.NewEncoder(file)
- if err != nil {
- return err
- }
- err = enc.Encode(ms.data)
+ enc := vom.NewEncoder(file)
if err := enc.Encode(ms.data); err != nil {
return verror.New(errEncodeFailed, nil, err)
}
diff --git a/services/wspr/internal/app/app.go b/services/wspr/internal/app/app.go
index 1496e41..c789fc6 100644
--- a/services/wspr/internal/app/app.go
+++ b/services/wspr/internal/app/app.go
@@ -497,12 +497,7 @@
w.Error(verror.Convert(verror.ErrInternal, ctx, fmt.Errorf("Error decoding hex string %q: %v", data, err)))
return
}
- decoder, err := vom.NewDecoder(bytes.NewReader(binbytes))
- if err != nil {
- w.Error(verror.Convert(verror.ErrInternal, ctx, err))
- return
- }
-
+ decoder := vom.NewDecoder(bytes.NewReader(binbytes))
var msg RpcRequest
if err := decoder.Decode(&msg); err != nil {
w.Error(verror.Convert(verror.ErrInternal, ctx, err))
diff --git a/services/wspr/internal/app/app_test.go b/services/wspr/internal/app/app_test.go
index e259890..9821146 100644
--- a/services/wspr/internal/app/app_test.go
+++ b/services/wspr/internal/app/app_test.go
@@ -295,10 +295,7 @@
func makeRequest(rpc RpcRequest, args ...interface{}) (string, error) {
var buf bytes.Buffer
- encoder, err := vom.NewEncoder(&buf)
- if err != nil {
- return "", err
- }
+ encoder := vom.NewEncoder(&buf)
if err := encoder.Encode(rpc); err != nil {
return "", err
}
diff --git a/services/wspr/internal/app/messaging.go b/services/wspr/internal/app/messaging.go
index 4a9e4d8..4fab9a9 100644
--- a/services/wspr/internal/app/messaging.go
+++ b/services/wspr/internal/app/messaging.go
@@ -133,19 +133,13 @@
// TODO(bprosnitz) Don't double-encode
func ConstructOutgoingMessage(messageId int32, messageType lib.ResponseType, data interface{}) (string, error) {
var buf bytes.Buffer
- enc, err := vom.NewEncoder(&buf)
- if err != nil {
- return "", err
- }
+ enc := vom.NewEncoder(&buf)
if err := enc.Encode(lib.Response{Type: messageType, Message: data}); err != nil {
return "", err
}
var buf2 bytes.Buffer
- enc2, err := vom.NewEncoder(&buf2)
- if err != nil {
- return "", err
- }
+ enc2 := vom.NewEncoder(&buf2)
if err := enc2.Encode(Message{Id: messageId, Data: fmt.Sprintf("%x", buf.Bytes())}); err != nil {
return "", err
}
diff --git a/services/wspr/internal/app/mock_jsServer_test.go b/services/wspr/internal/app/mock_jsServer_test.go
index 75e33ce..8fef5ee 100644
--- a/services/wspr/internal/app/mock_jsServer_test.go
+++ b/services/wspr/internal/app/mock_jsServer_test.go
@@ -273,10 +273,7 @@
}
var b bytes.Buffer
- enc, err := vom.NewEncoder(&b)
- if err != nil {
- panic(err)
- }
+ enc := vom.NewEncoder(&b)
if err := enc.Encode(resp); err != nil {
panic(err)
}
diff --git a/services/wspr/internal/browspr/browspr_test.go b/services/wspr/internal/browspr/browspr_test.go
index effb936..0debf32 100644
--- a/services/wspr/internal/browspr/browspr_test.go
+++ b/services/wspr/internal/browspr/browspr_test.go
@@ -186,10 +186,7 @@
}
var buf bytes.Buffer
- encoder, err := vom.NewEncoder(&buf)
- if err != nil {
- t.Fatalf("Failed to vom encode rpc message: %v", err)
- }
+ encoder := vom.NewEncoder(&buf)
if err := encoder.Encode(rpc); err != nil {
t.Fatalf("Failed to vom encode rpc message: %v", err)
}
diff --git a/services/wspr/internal/channel/channel_nacl/channel_nacl.go b/services/wspr/internal/channel/channel_nacl/channel_nacl.go
index 347a355..96ae623 100644
--- a/services/wspr/internal/channel/channel_nacl/channel_nacl.go
+++ b/services/wspr/internal/channel/channel_nacl/channel_nacl.go
@@ -21,10 +21,7 @@
func sendMessageToBrowser(ppapiInst ppapi.Instance, m channel.Message) {
var outBuf bytes.Buffer
- enc, err := vom.NewEncoder(&outBuf)
- if err != nil {
- panic(fmt.Sprintf("Error beginning encoding: %v", err))
- }
+ enc := vom.NewEncoder(&outBuf)
if err := enc.Encode(m); err != nil {
panic(fmt.Sprintf("Error encoding message %v: %v", m, err))
}
@@ -58,11 +55,7 @@
}
buf := bytes.NewBuffer(b)
- dec, err := vom.NewDecoder(buf)
- if err != nil {
- panic(fmt.Sprintf("Error beginning decoding: %v", err))
- }
-
+ dec := vom.NewDecoder(buf)
var m channel.Message
if err := dec.Decode(&m); err != nil {
panic(fmt.Sprintf("Error decoding message: %v", err))
diff --git a/services/wspr/internal/lib/vom.go b/services/wspr/internal/lib/vom.go
index 2ddbcfb..ef1f09d 100644
--- a/services/wspr/internal/lib/vom.go
+++ b/services/wspr/internal/lib/vom.go
@@ -14,10 +14,7 @@
func VomEncode(v interface{}) (string, error) {
var buf bytes.Buffer
- encoder, err := vom.NewEncoder(&buf)
- if err != nil {
- return "", err
- }
+ encoder := vom.NewEncoder(&buf)
if err := encoder.Encode(v); err != nil {
return "", err
}
@@ -37,9 +34,6 @@
if err != nil {
return fmt.Errorf("Error decoding hex string %q: %v", data, err)
}
- decoder, err := vom.NewDecoder(bytes.NewReader(binbytes))
- if err != nil {
- return err
- }
+ decoder := vom.NewDecoder(bytes.NewReader(binbytes))
return decoder.Decode(v)
}
diff --git a/services/wspr/internal/principal/principal.go b/services/wspr/internal/principal/principal.go
index da21e59..f13ac68 100644
--- a/services/wspr/internal/principal/principal.go
+++ b/services/wspr/internal/principal/principal.go
@@ -160,12 +160,7 @@
return nil, err
}
- decoder, err := vom.NewDecoder(vr)
-
- if err != nil {
- return nil, err
- }
-
+ decoder := vom.NewDecoder(vr)
if err := decoder.Decode(&result.state); err != nil {
return nil, err
}
@@ -182,11 +177,7 @@
return err
}
- encoder, err := vom.NewEncoder(swc)
-
- if err != nil {
- return err
- }
+ encoder := vom.NewEncoder(swc)
if err := encoder.Encode(i.state); err != nil {
return err
}
diff --git a/services/wspr/internal/principal/principal_test.go b/services/wspr/internal/principal/principal_test.go
index 2f86ef4..638727c 100644
--- a/services/wspr/internal/principal/principal_test.go
+++ b/services/wspr/internal/principal/principal_test.go
@@ -68,19 +68,11 @@
// Validate the integrity of the bits.
buf := new(bytes.Buffer)
- encoder, err := vom.NewEncoder(buf)
-
- if err != nil {
- return err
- }
-
+ encoder := vom.NewEncoder(buf)
if encoder.Encode(bOrigin); err != nil {
return err
}
- decoder, err := vom.NewDecoder(buf)
- if err != nil {
- return err
- }
+ decoder := vom.NewDecoder(buf)
var decoded security.Blessings
if err := decoder.Decode(&decoded); err != nil {
return err
