package torrent
import (
+ "encoding/json"
+ "fmt"
"io"
- "log"
"reflect"
"sync/atomic"
pp "github.com/anacrolix/torrent/peer_protocol"
)
-// Various connection-level metrics. At the Torrent level these are
-// aggregates. Chunks are messages with data payloads. Data is actual torrent
-// content without any overhead. Useful is something we needed locally.
-// Unwanted is something we didn't ask for (but may still be useful). Written
-// is things sent to the peer, and Read is stuff received from them.
+// Various connection-level metrics. At the Torrent level these are aggregates. Chunks are messages
+// with data payloads. Data is actual torrent content without any overhead. Useful is something we
+// needed locally. Unwanted is something we didn't ask for (but may still be useful). Written is
+// things sent to the peer, and Read is stuff received from them. Due to the implementation of
+// Count, must be aligned on some platforms: See https://github.com/anacrolix/torrent/issues/262.
type ConnStats struct {
// Total bytes on the wire. Includes handshakes and encryption.
BytesWritten Count
BytesWrittenData Count
- BytesRead Count
- BytesReadData Count
- BytesReadUsefulData Count
+ BytesRead Count
+ BytesReadData Count
+ BytesReadUsefulData Count
+ BytesReadUsefulIntendedData Count
ChunksWritten Count
- ChunksRead Count
- ChunksReadUseful Count
- ChunksReadUnwanted Count
+ ChunksRead Count
+ ChunksReadUseful Count
+ ChunksReadWasted Count
+
+ MetadataChunksRead Count
// Number of pieces data was written to, that subsequently passed verification.
PiecesDirtiedGood Count
- // Number of pieces data was written to, that subsequently failed
- // verification. Note that a connection may not have been the sole dirtier
- // of a piece.
+ // Number of pieces data was written to, that subsequently failed verification. Note that a
+ // connection may not have been the sole dirtier of a piece.
PiecesDirtiedBad Count
}
n int64
}
+var _ fmt.Stringer = (*Count)(nil)
+
func (me *Count) Add(n int64) {
atomic.AddInt64(&me.n, n)
}
return atomic.LoadInt64(&me.n)
}
+func (me *Count) String() string {
+ return fmt.Sprintf("%v", me.Int64())
+}
+
+func (me *Count) MarshalJSON() ([]byte, error) {
+ return json.Marshal(me.n)
+}
+
func (cs *ConnStats) wroteMsg(msg *pp.Message) {
// TODO: Track messages and not just chunks.
switch msg.Type {
}
}
-func (cs *ConnStats) readMsg(msg *pp.Message) {
- switch msg.Type {
- case pp.Piece:
- cs.ChunksRead.Add(1)
- cs.BytesReadData.Add(int64(len(msg.Piece)))
- }
+func (cs *ConnStats) receivedChunk(size int64) {
+ cs.ChunksRead.Add(1)
+ cs.BytesReadData.Add(size)
}
func (cs *ConnStats) incrementPiecesDirtiedGood() {
type connStatsReadWriter struct {
rw io.ReadWriter
- c *connection
+ c *PeerConn
}
func (me connStatsReadWriter) Write(b []byte) (n int, err error) {