func TestProcessor_AddMessage(t *testing.T) {
defer log.AfterTest(t)
p := NewServiceProcessor(nil)
log.ErrFatal(p.RegisterMessage(procMsg))
if len(p.functions) != 1 {
t.Fatal("Should have registered one function")
}
mt := network.TypeFromData(&testMsg{})
if mt == network.ErrorType {
t.Fatal("Didn't register message-type correctly")
}
var wrongFunctions = []interface{}{
procMsgWrong1,
procMsgWrong2,
procMsgWrong3,
procMsgWrong4,
procMsgWrong5,
procMsgWrong6,
}
for _, f := range wrongFunctions {
log.Lvl2("Checking function", reflect.TypeOf(f).String())
err := p.RegisterMessage(f)
if err == nil {
t.Fatalf("Shouldn't accept function %+s", reflect.TypeOf(f).String())
}
}
}
// sendSDAData marshals the inner msg and then sends a Data msg
// to the appropriate entity
func (h *Host) sendSDAData(e *network.ServerIdentity, sdaMsg *ProtocolMsg) error {
b, err := network.MarshalRegisteredType(sdaMsg.Msg)
if err != nil {
typ := network.TypeFromData(sdaMsg.Msg)
rtype := reflect.TypeOf(sdaMsg.Msg)
var str string
if typ == network.ErrorType {
str = " Non registered Type !"
} else {
str = typ.String()
}
str += " (reflect= " + rtype.String()
return fmt.Errorf("Error marshaling message: %s ( msg = %+v)", err.Error(), sdaMsg.Msg)
}
sdaMsg.MsgSlice = b
sdaMsg.MsgType = network.TypeFromData(sdaMsg.Msg)
// put to nil so protobuf won't encode it and there won't be any error on the
// other side (because it doesn't know how to decode it)
sdaMsg.Msg = nil
log.Lvl4("Sending to", e.Addresses)
return h.SendRaw(e, sdaMsg)
}
// Send opens the connection to 'dst' and sends the message 'req'. The
// reply is returned, or an error if the timeout of 10 seconds is reached.
func (c *Client) Send(dst *network.ServerIdentity, msg network.Body) (*network.Packet, error) {
c.Lock()
defer c.Unlock()
if c.host == nil {
kp := config.NewKeyPair(network.Suite)
c.host = network.NewSecureTCPHost(kp.Secret,
network.NewServerIdentity(kp.Public, ""))
}
// Connect to the root
log.Lvl4("Opening connection to", dst)
con, err := c.host.Open(dst)
defer c.host.Close()
if err != nil {
return nil, err
}
m, err := network.NewNetworkMessage(msg)
if err != nil {
return nil, err
}
b, err := m.MarshalBinary()
if err != nil {
return nil, err
}
serviceReq := &ClientRequest{
Service: c.ServiceID,
Data: b,
}
pchan := make(chan network.Packet)
go func() {
// send the request
log.Lvlf4("Sending request %x", serviceReq.Service)
if err := con.Send(context.TODO(), serviceReq); err != nil {
close(pchan)
return
}
log.Lvl4("Waiting for the response from", reflect.ValueOf(con).Pointer())
// wait for the response
packet, err := con.Receive(context.TODO())
if err != nil {
packet.Msg = StatusRet{err.Error()}
packet.MsgType = network.TypeFromData(&StatusRet{})
}
pchan <- packet
}()
select {
case response := <-pchan:
log.Lvlf5("Response: %+v %+v", response, response.Msg)
// Catch an eventual error
err := ErrMsg(&response, nil)
if err != nil {
return nil, err
}
return &response, nil
case <-time.After(time.Second * 10):
return &network.Packet{}, errors.New("Timeout on sending message")
}
}
