From 0088636798b04acea478e643d0fccaebf62bdb98 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Tue, 26 Apr 2016 10:07:00 +0700 Subject: [PATCH] rename OutgoingPacketAckHandler to SentPacketHandler --- ackhandler/interfaces.go | 4 +-- ..._ack_handler.go => sent_packet_handler.go} | 32 +++++++++---------- ...er_test.go => sent_packet_handler_test.go} | 6 ++-- session.go | 8 ++--- 4 files changed, 25 insertions(+), 25 deletions(-) rename ackhandler/{outgoing_packet_ack_handler.go => sent_packet_handler.go} (75%) rename ackhandler/{outgoing_packet_ack_handler_test.go => sent_packet_handler_test.go} (98%) diff --git a/ackhandler/interfaces.go b/ackhandler/interfaces.go index 1877a1860..91f678567 100644 --- a/ackhandler/interfaces.go +++ b/ackhandler/interfaces.go @@ -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 diff --git a/ackhandler/outgoing_packet_ack_handler.go b/ackhandler/sent_packet_handler.go similarity index 75% rename from ackhandler/outgoing_packet_ack_handler.go rename to ackhandler/sent_packet_handler.go index 0026dff1a..c587ad6fd 100644 --- a/ackhandler/outgoing_packet_ack_handler.go +++ b/ackhandler/sent_packet_handler.go @@ -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 } diff --git a/ackhandler/outgoing_packet_ack_handler_test.go b/ackhandler/sent_packet_handler_test.go similarity index 98% rename from ackhandler/outgoing_packet_ack_handler_test.go rename to ackhandler/sent_packet_handler_test.go index c2f69db4d..c3350d801 100644 --- a/ackhandler/outgoing_packet_ack_handler_test.go +++ b/ackhandler/sent_packet_handler_test.go @@ -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() { diff --git a/session.go b/session.go index 833a7d0f7..a095e9b09 100644 --- a/session.go +++ b/session.go @@ -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,