Remove onet.ClientError

Fixes #121.

local_test.go

@@ -42,8 +42,8 @@ func TestNewTCPTest(t *testing.T) {
 	defer l.CloseAll()
 
 	c1 := NewClient(clientServiceName, tSuite)
-	cerr := c1.SendProtobuf(el.List[0], &SimpleMessage{}, nil)
-	log.ErrFatal(cerr)
+	err := c1.SendProtobuf(el.List[0], &SimpleMessage{}, nil)
+	log.ErrFatal(err)
 }
 
 type clientService struct {
@@ -53,13 +53,13 @@ type clientService struct {
 
 type SimpleMessage2 struct{}
 
-func (c *clientService) SimpleMessage(msg *SimpleMessage) (network.Message, ClientError) {
+func (c *clientService) SimpleMessage(msg *SimpleMessage) (network.Message, error) {
 	log.Lvl3("Got request", msg)
 	c.cl.SendProtobuf(c.ServerIdentity(), &SimpleMessage2{}, nil)
 	return nil, nil
 }
 
-func (c *clientService) SimpleMessage2(msg *SimpleMessage2) (network.Message, ClientError) {
+func (c *clientService) SimpleMessage2(msg *SimpleMessage2) (network.Message, error) {
 	log.Lvl3("Got request", msg)
 	return nil, nil
 }

processor.go

@@ -39,12 +39,11 @@ var errType = reflect.TypeOf((*error)(nil)).Elem()
 // RegisterHandler will store the given handler that will be used by the service.
 // WebSocket will then forward requests to "ws://service_name/struct_name"
 // to the given function f, which must be of the following form:
-// func(msg interface{})(ret interface{}, err ClientError)
+// func(msg interface{})(ret interface{}, err error)
 //
 //  * msg is a pointer to a structure to the message sent.
 //  * ret is a pointer to a struct of the return-message.
-//  * err is a Client-error and can return nil or a ClientError that holds
-//	an error-id and an error-msg.
+//  * err is can be nil, or any type that implements error.
 //
 // struct_name is stripped of its package-name, so a structure like
 // network.Body will be converted to Body.
@@ -65,7 +64,7 @@ func (p *ServiceProcessor) RegisterHandler(f interface{}) error {
 		return errors.New("Argument must be a pointer to *struct*")
 	}
 	if ft.NumOut() != 2 {
-		return errors.New("Need 2 return values: network.Body and ClientError")
+		return errors.New("Need 2 return values: network.Body and error")
 	}
 
 	ret := ft.Out(0)
@@ -114,17 +113,17 @@ func (p *ServiceProcessor) NewProtocol(tn *TreeNodeInstance, conf *GenericConfig
 // ProcessClientRequest takes a request from a client, calculates the reply
 // and sends it back. It uses the path to find the appropriate handler-
 // function. It implements the Server interface.
-func (p *ServiceProcessor) ProcessClientRequest(path string, buf []byte) ([]byte, ClientError) {
+func (p *ServiceProcessor) ProcessClientRequest(path string, buf []byte) ([]byte, error) {
 	mh, ok := p.handlers[path]
-	reply, cerr := func() (interface{}, ClientError) {
+	reply, err := func() (interface{}, error) {
 		if !ok {
-			return nil, NewClientErrorCode(WebSocketErrorPathNotFound, "Path not found")
+			return nil, errors.New("Path not found")
 		}
 		msg := reflect.New(mh.msgType).Interface()
 		err := protobuf.DecodeWithConstructors(buf, msg,
 			network.DefaultConstructors(p.Context.server.Suite()))
 		if err != nil {
-			return nil, NewClientErrorCode(WebSocketErrorProtobufDecode, err.Error())
+			return nil, err
 		}
 
 		to := reflect.TypeOf(mh.handler).In(0)
@@ -136,20 +135,17 @@ func (p *ServiceProcessor) ProcessClientRequest(path string, buf []byte) ([]byte
 
 		ierr := ret[1].Interface()
 		if ierr != nil {
-			if cerr, ok := ierr.(ClientError); ok {
-				return nil, cerr
-			}
-			return nil, NewClientErrorCode(WebSocketErrorConverted, ierr.(error).Error())
+			return nil, ierr.(error)
 		}
 		return ret[0].Interface(), nil
 	}()
-	if cerr != nil {
-		return nil, cerr
+	if err != nil {
+		return nil, err
 	}
-	buf, err := protobuf.Encode(reply)
+	buf, err = protobuf.Encode(reply)
 	if err != nil {
 		log.Error(err)
-		return nil, NewClientErrorCode(WebSocketErrorProtobufEncode, "")
+		return nil, errors.New("")
 	}
 	return buf, nil
 }

processor_test.go

@@ -66,8 +66,8 @@ func TestServiceProcessor_ProcessClientRequest(t *testing.T) {
 
 	buf, err := protobuf.Encode(&testMsg{11})
 	log.ErrFatal(err)
-	rep, cerr := p.ProcessClientRequest("testMsg", buf)
-	require.Equal(t, nil, cerr)
+	rep, err := p.ProcessClientRequest("testMsg", buf)
+	require.Equal(t, nil, err)
 	val := &testMsg{}
 	log.ErrFatal(protobuf.Decode(rep, val))
 	if val.I != 11 {
@@ -76,15 +76,13 @@ func TestServiceProcessor_ProcessClientRequest(t *testing.T) {
 
 	buf, err = protobuf.Encode(&testMsg{42})
 	log.ErrFatal(err)
-	rep, cerr = p.ProcessClientRequest("testMsg", buf)
-	assert.NotNil(t, cerr)
-	require.Equal(t, 4005, cerr.ErrorCode())
+	rep, err = p.ProcessClientRequest("testMsg", buf)
+	assert.NotNil(t, err)
 
 	buf, err = protobuf.Encode(&testMsg2{42})
 	log.ErrFatal(err)
-	rep, cerr = p.ProcessClientRequest("testMsg2", buf)
-	assert.NotNil(t, cerr)
-	require.Equal(t, 4142, cerr.ErrorCode())
+	rep, err = p.ProcessClientRequest("testMsg2", buf)
+	assert.NotNil(t, err)
 }
 
 func TestProcessor_ProcessClientRequest(t *testing.T) {
@@ -96,8 +94,8 @@ func TestProcessor_ProcessClientRequest(t *testing.T) {
 
 	client := local.NewClient(testServiceName)
 	msg := &testMsg{}
-	cerr := client.SendProtobuf(h.ServerIdentity, &testMsg{12}, msg)
-	log.ErrFatal(cerr)
+	err := client.SendProtobuf(h.ServerIdentity, &testMsg{12}, msg)
+	log.ErrFatal(err)
 	if msg == nil {
 		t.Fatal("Msg should not be nil")
 	}
@@ -123,44 +121,44 @@ func procMsg(msg *testMsg) (network.Message, error) {
 	return msg, nil
 }
 
-func procMsg2(msg *testMsg2) (network.Message, ClientError) {
+func procMsg2(msg *testMsg2) (network.Message, error) {
 	// Return an error for testing
 	if msg.I == 42 {
-		return nil, NewClientErrorCode(4142, "42 is NOT the answer")
+		return nil, errors.New("42 is NOT the answer")
 	}
 	return nil, nil
 }
-func procMsg3(msg *testMsg3) (network.Message, ClientError) {
+func procMsg3(msg *testMsg3) (network.Message, error) {
 	return nil, nil
 }
-func procMsg4(msg *testMsg4) (*testMsg4, ClientError) {
+func procMsg4(msg *testMsg4) (*testMsg4, error) {
 	return msg, nil
 }
 
-func procMsgWrong1() (network.Message, ClientError) {
+func procMsgWrong1() (network.Message, error) {
 	return nil, nil
 }
 
-func procMsgWrong2(msg testMsg2) (network.Message, ClientError) {
+func procMsgWrong2(msg testMsg2) (network.Message, error) {
 	return msg, nil
 }
 
-func procMsgWrong3(msg *testMsg3) ClientError {
+func procMsgWrong3(msg *testMsg3) error {
 	return nil
 }
 
-func procMsgWrong4(msg *testMsg4) (ClientError, network.Message) {
+func procMsgWrong4(msg *testMsg4) (error, network.Message) {
 	return nil, msg
 }
 
-func procMsgWrong5(msg *testMsg) (*network.Message, ClientError) {
+func procMsgWrong5(msg *testMsg) (*network.Message, error) {
 	return nil, nil
 }
 
-func procMsgWrong6(msg *testMsg) (int, ClientError) {
+func procMsgWrong6(msg *testMsg) (int, error) {
 	return 10, nil
 }
-func procMsgWrong7(msg *testMsg) (testMsg, ClientError) {
+func procMsgWrong7(msg *testMsg) (testMsg, error) {
 	return *msg, nil
 }
 
@@ -181,7 +179,7 @@ func (ts *testService) NewProtocol(tn *TreeNodeInstance, conf *GenericConfig) (P
 	return nil, nil
 }
 
-func (ts *testService) ProcessMsg(msg *testMsg) (network.Message, ClientError) {
+func (ts *testService) ProcessMsg(msg *testMsg) (network.Message, error) {
 	ts.Msg = msg
 	return msg, nil
 }

service.go

@@ -31,11 +31,12 @@ type Service interface {
 	// the ProtocolInstance it is using. If a Service returns (nil,nil), that
 	// means this Service lets Onet handle the protocol instance.
 	NewProtocol(*TreeNodeInstance, *GenericConfig) (ProtocolInstance, error)
-	// ProcessClientRequest is called when a message from an external client is received by
-	// the websocket for this service. It returns a message that will be
-	// sent back to the client. The returned ClientError is either nil
-	// or any errorCode between 4100 and 4999.
-	ProcessClientRequest(handler string, msg []byte) (reply []byte, err ClientError)
+	// ProcessClientRequest is called when a message from an
+	// external client is received by the websocket for this
+	// service. It returns a message that will be sent back to the
+	// client. The returned error will be formatted as a websocket
+	// error code 4000, using the string form of the error as the message.
+	ProcessClientRequest(handler string, msg []byte) (reply []byte, err error)
 	// Processor makes a Service being able to handle any kind of packets
 	// directly from the network. It is used for inter service communications,
 	// which are mostly single packets with no or little interactions needed. If

service_test.go

@@ -2,6 +2,7 @@ package onet
 
 import (
 	"bytes"
+	"errors"
 	"testing"
 	"time"
 
@@ -94,11 +95,9 @@ func TestServiceProcessRequest(t *testing.T) {
 	// Send a request to the service
 	client := NewClient(dummyServiceName, tSuite)
 	log.Lvl1("Sending request to service...")
-	_, cerr := client.Send(server.ServerIdentity, "nil", []byte("a"))
+	_, err = client.Send(server.ServerIdentity, "nil", []byte("a"))
 	log.Lvl2("Got reply")
-	require.Error(t, cerr)
-	require.Equal(t, 4100, cerr.ErrorCode())
-	require.Equal(t, "wrong message", cerr.ErrorMsg())
+	require.Error(t, err)
 	// wait for the link
 	if <-link {
 		t.Fatal("was expecting false !")
@@ -135,8 +134,8 @@ func TestServiceRequestNewProtocol(t *testing.T) {
 
 	// Now resend the value so we instantiate using the same treenode
 	log.Lvl1("Sending request again to service...")
-	cerr := client.SendProtobuf(server.ServerIdentity, &DummyMsg{10}, nil)
-	assert.Error(t, cerr)
+	err := client.SendProtobuf(server.ServerIdentity, &DummyMsg{10}, nil)
+	assert.Error(t, err)
 	// this should fail
 	waitOrFatalValue(ds.link, false, t)
 }
@@ -260,8 +259,8 @@ func TestServiceBackForthProtocol(t *testing.T) {
 		Val:              10,
 	}
 	sr := &SimpleResponse{}
-	cerr := client.SendProtobuf(servers[0].ServerIdentity, r, sr)
-	log.ErrFatal(cerr)
+	err = client.SendProtobuf(servers[0].ServerIdentity, r, sr)
+	log.ErrFatal(err)
 	assert.Equal(t, sr.Val, 10)
 }
 
@@ -451,11 +450,11 @@ type simpleService struct {
 	ctx *Context
 }
 
-func (s *simpleService) ProcessClientRequest(path string, buf []byte) ([]byte, ClientError) {
+func (s *simpleService) ProcessClientRequest(path string, buf []byte) ([]byte, error) {
 	msg := &SimpleRequest{}
 	err := protobuf.DecodeWithConstructors(buf, msg, network.DefaultConstructors(tSuite))
 	if err != nil {
-		return nil, NewClientErrorCode(WebSocketErrorProtobufDecode, "")
+		return nil, errors.New("")
 	}
 	tree := msg.ServerIdentities.GenerateBinaryTree()
 	tni := s.ctx.NewTreeNodeInstance(tree, tree.Root, backForthServiceName)
@@ -464,15 +463,15 @@ func (s *simpleService) ProcessClientRequest(path string, buf []byte) ([]byte, C
 		ret <- n
 	})
 	if err != nil {
-		return nil, NewClientErrorCode(4100, "")
+		return nil, errors.New("")
 	}
 	if err = s.ctx.RegisterProtocolInstance(proto); err != nil {
-		return nil, NewClientErrorCode(4101, "")
+		return nil, errors.New("")
 	}
 	proto.Start()
 	resp, err := protobuf.Encode(&SimpleResponse{<-ret})
 	if err != nil {
-		return nil, NewClientErrorCode(4102, "")
+		return nil, errors.New("")
 	}
 	return resp, nil
 }
@@ -537,13 +536,13 @@ type DummyService struct {
 	Config   DummyConfig
 }
 
-func (ds *DummyService) ProcessClientRequest(path string, buf []byte) ([]byte, ClientError) {
+func (ds *DummyService) ProcessClientRequest(path string, buf []byte) ([]byte, error) {
 	log.Lvl2("Got called with path", path, buf)
 	msg := &DummyMsg{}
 	err := protobuf.Decode(buf, msg)
 	if err != nil {
 		ds.link <- false
-		return nil, NewClientErrorCode(4100, "wrong message")
+		return nil, errors.New("wrong message")
 	}
 	if ds.firstTni == nil {
 		ds.firstTni = ds.c.NewTreeNodeInstance(ds.fakeTree, ds.fakeTree.Root, dummyServiceName)
@@ -553,7 +552,7 @@ func (ds *DummyService) ProcessClientRequest(path string, buf []byte) ([]byte, C
 
 	if err := ds.c.RegisterProtocolInstance(dp); err != nil {
 		ds.link <- false
-		return nil, NewClientErrorCode(4101, "")
+		return nil, errors.New("")
 	}
 	log.Lvl2("Starting protocol")
 	go func() {
@@ -607,7 +606,7 @@ func newDummyService2(c *Context) (Service, error) {
 	return &dummyService2{Context: c}, nil
 }
 
-func (ds *dummyService2) ProcessClientRequest(path string, buf []byte) ([]byte, ClientError) {
+func (ds *dummyService2) ProcessClientRequest(path string, buf []byte) ([]byte, error) {
 	panic("should not be called")
 }