func (ctx *ClientContext) startHandler() {
    log, _ := logger.New("handler-" + strconv.Itoa(lastClient), 1)
    log.SetLogLevel(defaultLogLevel)

    defer func() {
        if r := recover(); r != nil {
            log.Criticalf("PANIC! %v", r)
        }
    }()

outerLoop:
    for {
        var size uint16
        err := binary.Read(ctx.Conn, binary.BigEndian, &size)
        if err != nil {
            log.Errorf("Error happened: %v", err)
            break
        }
        // TODO: Size limiting
        buf := make([]byte, size)
        read := 0
        for read != int(size) {
            _read, err := ctx.Conn.Read(buf[read:])
            read += _read
            if err != nil {
                log.Errorf("Error occurred while reading from client:", err)
                break outerLoop
            }
        }

        header := protocol.MessageHeader{}
        if ctx.Encoding == "" {
            log.Debug("No encoding set, trying to guess")
            err = json.Unmarshal(buf, header)
            if err != nil {
                log.Debug("JSON decode failed, moving on")
                _, err = header.UnmarshalMsg(buf)
                if err != nil {
                    log.Debug("MessagePack decode failed, closing the connection")
                    break
                } else {
                    log.Debug("Determined that encoding is msgpack")
                    ctx.Encoding = "msgpack"
                }
            } else {
                log.Debug("Determined that encoding is json")
                ctx.Encoding = "json"
            }
        } else {
            header, err = ctx.ReadHeader(buf)
            if err != nil {
                log.Debugf("Message decode failed: %v", err)
                header, errBody := protocol.NewError(protocol.ErrDeserializationFailure, protocol.ErrDeserializationFailureDesc)
                err = ctx.Reply(header, errBody)
                if err != nil {
                    log.Warningf("Failed writing reply to client: %v", err)
                }
                // On deserialization failure we cannot be sure that connection is clear
                // TODO: Is closing the connection a valid strategy?
                break
            }
        }
        result, clientErr, err := ctx.ProcessMessage(&header)
        if err != nil {
            log.Criticalf("Message processing failed: %v", err)
            header, errBody := protocol.NewError(protocol.ErrInternalServerError, protocol.ErrInternalServerErrorDesc)
            err = ctx.Reply(header, errBody)
            if err != nil {
                log.Warningf("Failed writing reply to client: %v", err)
                break
            }
            continue
        }
        if clientErr != nil {
            header.Type = protocol.TypeError
            err = ctx.Reply(header, clientErr)
            if err != nil {
                log.Warningf("Failed writing reply to client: %v", err)
                break
            }
            continue
        }
        err = ctx.Reply(header, result)
        if err != nil {
            log.Warningf("Failed writing reply to client: %v", err)
            break
        }
    }
    log.Debug("Connection is closed")
    _ = ctx.Conn.Close()
}