Server failing to parse packets when flooded too fast

Here's the error I get when I flood the server with too many packets per second:

2014/11/28 12:52:49 main.go:59: loading plugin: print
2014/11/28 12:52:49 main.go:86: starting server on 0.0.0.0:8080
2014/11/28 12:52:59 server.go:15: client has connected: 127.0.0.1:59146
2014/11/28 12:52:59 server.go:43: received data from client 127.0.0.1:59146: &main.Observation{SensorId:"1", Timestamp:1416492023}
2014/11/28 12:52:59 server.go:29: read error from 127.0.0.1:59146: zlib: invalid header
2014/11/28 12:52:59 server.go:18: closing connection to: 127.0.0.1:59146

It manages to decode one packet (sometimes, maybe 2 or 3) then errors out. Here's the code doing the flooding:

import socket
import struct
import json
import zlib
import time

def serialize(data):
    data = json.dumps(data)
    data = zlib.compress(data)

    packet  = struct.pack('!I', len(data))
    packet += data

    return len(data), packet

message = {
    'sensor_id': '1',
    'timestamp': 1416492023,
}

length, buffer = serialize([message])

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

client.connect(('127.0.0.1', 8080))

while True:
    client.send(buffer)

    #time.sleep(0.0005)

When I uncomment the time.sleep() call, the server works fine. It seems too many packets/per second is killing the server. Why?

Here's the relevent Go code. The connection handler:

func (self *Server) handleConnection(connection net.Conn) {
    for {
        connection.SetReadDeadline(time.Now().Add(30 * time.Second))

        observations, err := self.Protocol.Unserialize(connection)

        if err != nil {
            log.Printf("read error from %s: %s\n", connection.RemoteAddr(), err)

            return
        }
}

And here's the unserializer:

// Length Value protocol to read zlib compressed, JSON encoded packets.
type ProtocolV2 struct{}

func (self *ProtocolV2) Unserialize(packet io.Reader) ([]*Observation, error) {
    var length uint32

    if err := binary.Read(packet, binary.BigEndian, &length); err != nil {
        return nil, err
    }

    buffer := make([]byte, length)
    rawreader := bufio.NewReader(packet)

    if _, err := rawreader.Read(buffer); err != nil {
        return nil, err
    }

    bytereader := bytes.NewReader(buffer)
    zreader, err := zlib.NewReader(bytereader)

    if err != nil {
        return nil, err
    }

    defer zreader.Close()

    var observations []*Observation

    decoder := json.NewDecoder(zreader)

    if err := decoder.Decode(&observations); err != nil {
        return nil, err
    }

    return observations, nil
}

It seems there is an error on client side in the Python script.

The return of client.send is not checked, so the script does not handle partial writes in a correct way. Basically, when the socket buffer is full, only part of the message will be written, resulting in the server unable to decode the message.

This code is broken, but adding the wait makes it work because it prevents the socket buffer to be full.

You can use client.sendall instead to ensure the write operations are complete.

More information in the Python documentation:

https://docs.python.org/2/library/socket.html

https://docs.python.org/2/howto/sockets.html#using-a-socket

Now in the Go server, there is also a similar problem. The documentation says:

> Read reads data into p. It returns the number of bytes read into p. It calls Read at most once on the underlying Reader, hence n may be less than len(p). At EOF, the count will be zero and err will be io.EOF.

The rawreader.Read call may return less bytes than you expect. You may want to use the ReadFull() function of the io package to ensure the full message is read.