gr1ffon/quic-go
1
0
Fork 0
forked from quic-go/quic-go
Code Pull Requests Activity

rename OutgoingPacketAckHandler to SentPacketHandler

Browse Source
This commit is contained in:
Marten Seemann
2016-04-26 10:07:00 +07:00
parent ccc6d23a7d
commit 0088636798
4 changed files with 25 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
ackhandler/interfaces.go
View File

@@ -5,8 +5,8 @@ import (
"github.com/lucas-clemente/quic-go/protocol"
)
// OutgoingPacketAckHandler handles ACKs received for outgoing packets
type OutgoingPacketAckHandler interface {
// SentPacketHandler handles ACKs received for outgoing packets
type SentPacketHandler interface {
SentPacket(packet *Packet) error
ReceivedAck(ackFrame *frames.AckFrame) error

32
ackhandler/outgoing_packet_ack_handler.go → ackhandler/sent_packet_handler.go
View File

@@ -8,14 +8,14 @@ import (
)
var (
errAckForUnsentPacket = errors.New("OutgoingPacketAckHandler: Received ACK for an unsent package")
errDuplicateOrOutOfOrderAck = errors.New("OutgoingPacketAckHandler: Duplicate or out-of-order ACK")
errEntropy = errors.New("OutgoingPacketAckHandler: Wrong entropy")
errMapAccess = errors.New("OutgoingPacketAckHandler: Packet does not exist in PacketHistory")
errAckForUnsentPacket = errors.New("SentPacketHandler: Received ACK for an unsent package")
errDuplicateOrOutOfOrderAck = errors.New("SentPacketHandler: Duplicate or out-of-order ACK")
errEntropy = errors.New("SentPacketHandler: Wrong entropy")
errMapAccess = errors.New("SentPacketHandler: Packet does not exist in PacketHistory")
retransmissionThreshold = uint8(3)
)
type outgoingPacketAckHandler struct {
type sentPacketHandler struct {
lastSentPacketNumber protocol.PacketNumber
lastSentPacketEntropy EntropyAccumulator
highestInOrderAckedPacketNumber protocol.PacketNumber
@@ -27,18 +27,18 @@ type outgoingPacketAckHandler struct {
retransmissionQueue []*Packet // ToDo: use better data structure
}
// NewOutgoingPacketAckHandler creates a new outgoingPacketAckHandler
func NewOutgoingPacketAckHandler() OutgoingPacketAckHandler {
return &outgoingPacketAckHandler{
// NewSentPacketHandler creates a new sentPacketHandler
func NewSentPacketHandler() SentPacketHandler {
return &sentPacketHandler{
packetHistory: make(map[protocol.PacketNumber]*Packet),
}
}
func (h *outgoingPacketAckHandler) ackPacket(packetNumber protocol.PacketNumber) {
func (h *sentPacketHandler) ackPacket(packetNumber protocol.PacketNumber) {
delete(h.packetHistory, packetNumber)
}
func (h *outgoingPacketAckHandler) nackPacket(packetNumber protocol.PacketNumber) error {
func (h *sentPacketHandler) nackPacket(packetNumber protocol.PacketNumber) error {
packet, ok := h.packetHistory[packetNumber]
if !ok {
return errMapAccess
@@ -52,7 +52,7 @@ func (h *outgoingPacketAckHandler) nackPacket(packetNumber protocol.PacketNumber
return nil
}
func (h *outgoingPacketAckHandler) recalculateHighestInOrderAckedPacketNumberFromPacketHistory() {
func (h *sentPacketHandler) recalculateHighestInOrderAckedPacketNumberFromPacketHistory() {
for i := h.highestInOrderAckedPacketNumber; i <= h.lastSentPacketNumber; i++ {
_, ok := h.packetHistory[i]
if ok {
@@ -62,13 +62,13 @@ func (h *outgoingPacketAckHandler) recalculateHighestInOrderAckedPacketNumberFro
}
}
func (h *outgoingPacketAckHandler) queuePacketForRetransmission(packet *Packet) {
func (h *sentPacketHandler) queuePacketForRetransmission(packet *Packet) {
h.retransmissionQueue = append(h.retransmissionQueue, packet)
h.ackPacket(packet.PacketNumber)
h.recalculateHighestInOrderAckedPacketNumberFromPacketHistory()
}
func (h *outgoingPacketAckHandler) SentPacket(packet *Packet) error {
func (h *sentPacketHandler) SentPacket(packet *Packet) error {
_, ok := h.packetHistory[packet.PacketNumber]
if ok {
return errors.New("Packet number already exists in Packet History")
@@ -84,7 +84,7 @@ func (h *outgoingPacketAckHandler) SentPacket(packet *Packet) error {
return nil
}
func (h *outgoingPacketAckHandler) calculateExpectedEntropy(ackFrame *frames.AckFrame) (EntropyAccumulator, error) {
func (h *sentPacketHandler) calculateExpectedEntropy(ackFrame *frames.AckFrame) (EntropyAccumulator, error) {
packet, ok := h.packetHistory[ackFrame.LargestObserved]
if !ok {
return 0, errMapAccess
@@ -113,7 +113,7 @@ func (h *outgoingPacketAckHandler) calculateExpectedEntropy(ackFrame *frames.Ack
return expectedEntropy, nil
}
func (h *outgoingPacketAckHandler) ReceivedAck(ackFrame *frames.AckFrame) error {
func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame) error {
if ackFrame.LargestObserved > h.lastSentPacketNumber {
return errAckForUnsentPacket
}
@@ -163,7 +163,7 @@ func (h *outgoingPacketAckHandler) ReceivedAck(ackFrame *frames.AckFrame) error
return nil
}
func (h *outgoingPacketAckHandler) DequeuePacketForRetransmission() (packet *Packet) {
func (h *sentPacketHandler) DequeuePacketForRetransmission() (packet *Packet) {
if len(h.retransmissionQueue) == 0 {
return nil
}

6
ackhandler/outgoing_packet_ack_handler_test.go → ackhandler/sent_packet_handler_test.go
View File

@@ -7,10 +7,10 @@ import (
. "github.com/onsi/gomega"
)
var _ = Describe("AckHandler", func() {
var handler *outgoingPacketAckHandler
var _ = Describe("SentPacketHandler", func() {
var handler *sentPacketHandler
BeforeEach(func() {
handler = NewOutgoingPacketAckHandler().(*outgoingPacketAckHandler)
handler = NewSentPacketHandler().(*sentPacketHandler)
})
Context("SentPacket", func() {

8
session.go
View File

@@ -34,7 +34,7 @@ type Session struct {
streams map[protocol.StreamID]*stream
streamsMutex sync.RWMutex
outgoingAckHandler ackhandler.OutgoingPacketAckHandler
sentPacketHandler ackhandler.SentPacketHandler
incomingAckHandler ackhandler.IncomingPacketAckHandler
unpacker *packetUnpacker
@@ -49,7 +49,7 @@ func NewSession(conn *net.UDPConn, v protocol.VersionNumber, connectionID protoc
connection: conn,
streamCallback: streamCallback,
streams: make(map[protocol.StreamID]*stream),
outgoingAckHandler: ackhandler.NewOutgoingPacketAckHandler(),
sentPacketHandler: ackhandler.NewSentPacketHandler(),
incomingAckHandler: ackhandler.NewIncomingPacketAckHandler(),
receivedPackets: make(chan receivedPacket),
}
@@ -104,7 +104,7 @@ func (s *Session) handlePacket(addr *net.UDPAddr, publicHeader *PublicHeader, r
case *frames.StreamFrame:
err = s.handleStreamFrame(frame)
case *frames.AckFrame:
err = s.outgoingAckHandler.ReceivedAck(frame)
err = s.sentPacketHandler.ReceivedAck(frame)
// ToDo: send right error in ConnectionClose frame
case *frames.ConnectionCloseFrame:
fmt.Printf("%#v\n", frame)
@@ -189,7 +189,7 @@ func (s *Session) sendPacket() error {
if packet == nil {
return nil
}
s.outgoingAckHandler.SentPacket(&ackhandler.Packet{
s.sentPacketHandler.SentPacket(&ackhandler.Packet{
PacketNumber: packet.number,
Plaintext: packet.payload,
EntropyBit: packet.entropyBit,