func TestProcessor_GetReply(t *testing.T) {
defer log.AfterTest(t)
p := NewServiceProcessor(nil)
log.ErrFatal(p.RegisterMessage(procMsg))
pair := config.NewKeyPair(network.Suite)
e := network.NewServerIdentity(pair.Public, "")
rep := p.GetReply(e, mkClientRequest(&testMsg{11}))
val, ok := rep.(*testMsg)
if !ok {
t.Fatalf("Couldn't cast reply to testMsg: %+v", rep)
}
if val.I != 11 {
t.Fatal("Value got lost - should be 11")
}
rep = p.GetReply(e, mkClientRequest(&testMsg{42}))
errMsg, ok := rep.(*StatusRet)
if !ok {
t.Fatal("42 should return an error")
}
if errMsg.Status == "" {
t.Fatal("The error should be non-empty")
}
}
// CreateRoster creates an Roster with the host-names in 'addresses'.
// It creates 's.Hosts' entries, starting from 'port' for each round through
// 'addresses'
func (s *SimulationBFTree) CreateRoster(sc *SimulationConfig, addresses []string, port int) {
start := time.Now()
nbrAddr := len(addresses)
if sc.PrivateKeys == nil {
sc.PrivateKeys = make(map[string]abstract.Scalar)
}
hosts := s.Hosts
if s.SingleHost {
// If we want to work with a single host, we only make one
// host per server
log.Fatal("Not supported yet")
hosts = nbrAddr
if hosts > s.Hosts {
hosts = s.Hosts
}
}
localhosts := false
listeners := make([]net.Listener, hosts)
if strings.Contains(addresses[0], "localhost") {
localhosts = true
}
entities := make([]*network.ServerIdentity, hosts)
log.Lvl3("Doing", hosts, "hosts")
key := config.NewKeyPair(network.Suite)
for c := 0; c < hosts; c++ {
key.Secret.Add(key.Secret,
key.Suite.Scalar().One())
key.Public.Add(key.Public,
key.Suite.Point().Base())
address := addresses[c%nbrAddr] + ":"
if localhosts {
// If we have localhosts, we have to search for an empty port
var err error
listeners[c], err = net.Listen("tcp", ":0")
if err != nil {
log.Fatal("Couldn't search for empty port:", err)
}
_, p, _ := net.SplitHostPort(listeners[c].Addr().String())
address += p
log.Lvl4("Found free port", address)
} else {
address += strconv.Itoa(port + c/nbrAddr)
}
entities[c] = network.NewServerIdentity(key.Public, address)
sc.PrivateKeys[entities[c].Addresses[0]] = key.Secret
}
// And close all our listeners
if localhosts {
for _, l := range listeners {
err := l.Close()
if err != nil {
log.Fatal("Couldn't close port:", l, err)
}
}
}
sc.Roster = NewRoster(entities)
log.Lvl3("Creating entity List took: " + time.Now().Sub(start).String())
}
func TestServiceBackForthProtocol(t *testing.T) {
local := sda.NewLocalTest()
defer local.CloseAll()
// register service
sda.RegisterNewService("BackForth", func(c *sda.Context, path string) sda.Service {
return &simpleService{
ctx: c,
}
})
// create hosts
hosts, el, _ := local.GenTree(4, true, true, false)
// create client
priv, pub := sda.PrivPub()
client := network.NewSecureTCPHost(priv, network.NewServerIdentity(pub, ""))
c, err := client.Open(hosts[0].ServerIdentity)
assert.Nil(t, err)
// create request
r := &simpleRequest{
ServerIdentities: el,
Val: 10,
}
buff, err := network.MarshalRegisteredType(r)
assert.Nil(t, err)
req := &sda.ClientRequest{
Service: sda.ServiceFactory.ServiceID("BackForth"),
Data: buff,
}
assert.Nil(t, c.Send(context.TODO(), req))
nm, err := c.Receive(context.TODO())
assert.Nil(t, err)
assert.Equal(t, nm.MsgType, simpleResponseType)
resp := nm.Msg.(simpleResponse)
assert.Equal(t, resp.Val, 10)
}
// NewLocalHost creates a new host with the given address and registers it.
func NewLocalHost(port int) *Host {
address := "localhost:" + strconv.Itoa(port)
priv, pub := PrivPub()
id := network.NewServerIdentity(pub, address)
return NewHost(id, priv)
}
// 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")
}
}
func newHostMock(s abstract.Suite, address string) *Host {
kp := config.NewKeyPair(s)
en := network.NewServerIdentity(kp.Public, address)
return NewHost(en, kp.Secret)
}
