_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q22000 | Unmarshal | train | func Unmarshal(data []byte, v interface{}) (err error) {
buf := bytes.NewBuffer(data)
e := Decoder{r: buf}
err = e.Decode(v)
if err == nil && buf.Len() != 0 {
err = ErrUnusedTrailingBytes{buf.Len()}
}
return
} | go | {
"resource": ""
} |
q22001 | SetResponsive | train | func (r *reader) SetResponsive() {
r.responsive = true
r.t.cl.event.Broadcast()
} | go | {
"resource": ""
} |
q22002 | SetReadahead | train | func (r *reader) SetReadahead(readahead int64) {
r.mu.Lock()
r.readahead = readahead
r.mu.Unlock()
r.t.cl.lock()
defer r.t.cl.unlock()
r.posChanged()
} | go | {
"resource": ""
} |
q22003 | available | train | func (r *reader) available(off, max int64) (ret int64) {
off += r.offset
for max > 0 {
req, ok := r.t.offsetRequest(off)
if !ok {
break
}
if !r.t.haveChunk(req) {
break
}
len1 := int64(req.Length) - (off - r.t.requestOffset(req))
max -= len1
ret += len1
off += len1
}
// Ensure that ret hasn'... | go | {
"resource": ""
} |
q22004 | piecesUncached | train | func (r *reader) piecesUncached() (ret pieceRange) {
ra := r.readahead
if ra < 1 {
// Needs to be at least 1, because [x, x) means we don't want
// anything.
ra = 1
}
if ra > r.length-r.pos {
ra = r.length - r.pos
}
ret.begin, ret.end = r.t.byteRegionPieces(r.torrentOffset(r.pos), ra)
return
} | go | {
"resource": ""
} |
q22005 | waitAvailable | train | func (r *reader) waitAvailable(pos, wanted int64, ctxErr *error) (avail int64) {
r.t.cl.lock()
defer r.t.cl.unlock()
for !r.readable(pos) && *ctxErr == nil {
r.waitReadable(pos)
}
return r.available(pos, wanted)
} | go | {
"resource": ""
} |
q22006 | readOnceAt | train | func (r *reader) readOnceAt(b []byte, pos int64, ctxErr *error) (n int, err error) {
if pos >= r.length {
err = io.EOF
return
}
for {
avail := r.waitAvailable(pos, int64(len(b)), ctxErr)
if avail == 0 {
if r.t.closed.IsSet() {
err = errors.New("torrent closed")
return
}
if *ctxErr != nil {
... | go | {
"resource": ""
} |
q22007 | write | train | func (c *udpAnnounce) write(h *RequestHeader, body interface{}, trailer []byte) (err error) {
var buf bytes.Buffer
err = binary.Write(&buf, binary.BigEndian, h)
if err != nil {
panic(err)
}
if body != nil {
err = binary.Write(&buf, binary.BigEndian, body)
if err != nil {
panic(err)
}
}
_, err = buf.Wr... | go | {
"resource": ""
} |
q22008 | request | train | func (c *udpAnnounce) request(action Action, args interface{}, options []byte) (*bytes.Buffer, error) {
tid := newTransactionId()
if err := errors.Wrap(
c.write(
&RequestHeader{
ConnectionId: c.connectionId,
Action: action,
TransactionId: tid,
}, args, options),
"writing request",
); er... | go | {
"resource": ""
} |
q22009 | metadataPieceSize | train | func metadataPieceSize(totalSize int, piece int) int {
ret := totalSize - piece*(1<<14)
if ret > 1<<14 {
ret = 1 << 14
}
return ret
} | go | {
"resource": ""
} |
q22010 | torrentOffsetRequest | train | func torrentOffsetRequest(torrentLength, pieceSize, chunkSize, offset int64) (
r request, ok bool) {
if offset < 0 || offset >= torrentLength {
return
}
r.Index = pp.Integer(offset / pieceSize)
r.Begin = pp.Integer(offset % pieceSize / chunkSize * chunkSize)
r.Length = pp.Integer(chunkSize)
pieceLeft := pp.Int... | go | {
"resource": ""
} |
q22011 | Handshake | train | func Handshake(sock io.ReadWriter, ih *metainfo.Hash, peerID [20]byte, extensions PeerExtensionBits) (res HandshakeResult, ok bool, err error) {
// Bytes to be sent to the peer. Should never block the sender.
postCh := make(chan []byte, 4)
// A single error value sent when the writer completes.
writeDone := make(ch... | go | {
"resource": ""
} |
q22012 | readUntil | train | func (d *Decoder) readUntil(sep byte) {
for {
b := d.readByte()
if b == sep {
return
}
d.buf.WriteByte(b)
}
} | go | {
"resource": ""
} |
q22013 | parseInt | train | func (d *Decoder) parseInt(v reflect.Value) {
start := d.Offset - 1
d.readUntil('e')
if d.buf.Len() == 0 {
panic(&SyntaxError{
Offset: start,
What: errors.New("empty integer value"),
})
}
s := bytesAsString(d.buf.Bytes())
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int3... | go | {
"resource": ""
} |
q22014 | getDictField | train | func getDictField(dict reflect.Value, key string) dictField {
// get valuev as a map value or as a struct field
switch dict.Kind() {
case reflect.Map:
value := reflect.New(dict.Type().Elem()).Elem()
return dictField{
Value: value,
Ok: true,
Set: func() {
if dict.IsNil() {
dict.Set(reflect.Ma... | go | {
"resource": ""
} |
q22015 | raiseUnknownValueType | train | func (d *Decoder) raiseUnknownValueType(b byte, offset int64) {
panic(&SyntaxError{
Offset: offset,
What: fmt.Errorf("unknown value type %+q", b),
})
} | go | {
"resource": ""
} |
q22016 | announce | train | func (me *trackerScraper) announce() (ret trackerAnnounceResult) {
defer func() {
ret.Completed = time.Now()
}()
ret.Interval = 5 * time.Minute
ip, err := me.getIp()
if err != nil {
ret.Err = fmt.Errorf("error getting ip: %s", err)
return
}
me.t.cl.lock()
req := me.t.announceRequest()
me.t.cl.unlock()
r... | go | {
"resource": ""
} |
q22017 | IPNetLast | train | func IPNetLast(in *net.IPNet) (last net.IP) {
n := len(in.IP)
if n != len(in.Mask) {
panic("wat")
}
last = make(net.IP, n)
for i := 0; i < n; i++ {
last[i] = in.IP[i] | ^in.Mask[i]
}
return
} | go | {
"resource": ""
} |
q22018 | reflectMarshaler | train | func (e *Encoder) reflectMarshaler(v reflect.Value) bool {
if !v.Type().Implements(marshalerType) {
if v.Kind() != reflect.Ptr && v.CanAddr() && v.Addr().Type().Implements(marshalerType) {
v = v.Addr()
} else {
return false
}
}
m := v.Interface().(Marshaler)
data, err := m.MarshalBencode()
if err != ni... | go | {
"resource": ""
} |
q22019 | DisplayPath | train | func (f *File) DisplayPath() string {
fip := f.FileInfo().Path
if len(fip) == 0 {
return f.t.info.Name
}
return strings.Join(fip, "/")
} | go | {
"resource": ""
} |
q22020 | State | train | func (f *File) State() (ret []FilePieceState) {
f.t.cl.rLock()
defer f.t.cl.rUnlock()
pieceSize := int64(f.t.usualPieceSize())
off := f.offset % pieceSize
remaining := f.length
for i := pieceIndex(f.offset / pieceSize); ; i++ {
if remaining == 0 {
break
}
len1 := pieceSize - off
if len1 > remaining {
... | go | {
"resource": ""
} |
q22021 | SetPriority | train | func (f *File) SetPriority(prio piecePriority) {
f.t.cl.lock()
defer f.t.cl.unlock()
if prio == f.prio {
return
}
f.prio = prio
f.t.updatePiecePriorities(f.firstPieceIndex(), f.endPieceIndex())
} | go | {
"resource": ""
} |
q22022 | Priority | train | func (f *File) Priority() piecePriority {
f.t.cl.lock()
defer f.t.cl.unlock()
return f.prio
} | go | {
"resource": ""
} |
q22023 | WriteStatus | train | func (cl *Client) WriteStatus(_w io.Writer) {
cl.rLock()
defer cl.rUnlock()
w := bufio.NewWriter(_w)
defer w.Flush()
fmt.Fprintf(w, "Listen port: %d\n", cl.LocalPort())
fmt.Fprintf(w, "Peer ID: %+q\n", cl.PeerID())
fmt.Fprintf(w, "Announce key: %x\n", cl.announceKey())
fmt.Fprintf(w, "Banned IPs: %d\n", len(cl.... | go | {
"resource": ""
} |
q22024 | Close | train | func (cl *Client) Close() {
cl.lock()
defer cl.unlock()
cl.closed.Set()
cl.eachDhtServer(func(s *dht.Server) { s.Close() })
cl.closeSockets()
for _, t := range cl.torrents {
t.close()
}
for _, f := range cl.onClose {
f()
}
cl.event.Broadcast()
} | go | {
"resource": ""
} |
q22025 | Torrent | train | func (cl *Client) Torrent(ih metainfo.Hash) (t *Torrent, ok bool) {
cl.lock()
defer cl.unlock()
t, ok = cl.torrents[ih]
return
} | go | {
"resource": ""
} |
q22026 | dopplegangerAddr | train | func (cl *Client) dopplegangerAddr(addr string) bool {
_, ok := cl.dopplegangerAddrs[addr]
return ok
} | go | {
"resource": ""
} |
q22027 | dialFirst | train | func (cl *Client) dialFirst(ctx context.Context, addr string) dialResult {
ctx, cancel := context.WithCancel(ctx)
// As soon as we return one connection, cancel the others.
defer cancel()
left := 0
resCh := make(chan dialResult, left)
func() {
cl.lock()
defer cl.unlock()
cl.eachListener(func(s socket) bool ... | go | {
"resource": ""
} |
q22028 | outgoingConnection | train | func (cl *Client) outgoingConnection(t *Torrent, addr IpPort, ps peerSource) {
cl.dialRateLimiter.Wait(context.Background())
c, err := cl.establishOutgoingConn(t, addr)
cl.lock()
defer cl.unlock()
// Don't release lock between here and addConnection, unless it's for
// failure.
cl.noLongerHalfOpen(t, addr.String... | go | {
"resource": ""
} |
q22029 | forSkeys | train | func (cl *Client) forSkeys(f func([]byte) bool) {
cl.lock()
defer cl.unlock()
for ih := range cl.torrents {
if !f(ih[:]) {
break
}
}
} | go | {
"resource": ""
} |
q22030 | receiveHandshakes | train | func (cl *Client) receiveHandshakes(c *connection) (t *Torrent, err error) {
defer perf.ScopeTimerErr(&err)()
var rw io.ReadWriter
rw, c.headerEncrypted, c.cryptoMethod, err = handleEncryption(c.rw(), cl.forSkeys, cl.config.EncryptionPolicy)
c.setRW(rw)
if err == nil || err == mse.ErrNoSecretKeyMatch {
if c.head... | go | {
"resource": ""
} |
q22031 | connBTHandshake | train | func (cl *Client) connBTHandshake(c *connection, ih *metainfo.Hash) (ret metainfo.Hash, ok bool, err error) {
res, ok, err := pp.Handshake(c.rw(), ih, cl.peerID, cl.extensionBytes)
if err != nil || !ok {
return
}
ret = res.Hash
c.PeerExtensionBytes = res.PeerExtensionBits
c.PeerID = res.PeerID
c.completedHands... | go | {
"resource": ""
} |
q22032 | sendInitialMessages | train | func (cl *Client) sendInitialMessages(conn *connection, torrent *Torrent) {
if conn.PeerExtensionBytes.SupportsExtended() && cl.extensionBytes.SupportsExtended() {
conn.Post(pp.Message{
Type: pp.Extended,
ExtendedID: pp.HandshakeExtendedID,
ExtendedPayload: func() []byte {
msg := pp.ExtendedHandsh... | go | {
"resource": ""
} |
q22033 | gotMetadataExtensionMsg | train | func (cl *Client) gotMetadataExtensionMsg(payload []byte, t *Torrent, c *connection) error {
var d map[string]int
err := bencode.Unmarshal(payload, &d)
if _, ok := err.(bencode.ErrUnusedTrailingBytes); ok {
} else if err != nil {
return fmt.Errorf("error unmarshalling bencode: %s", err)
}
msgType, ok := d["msg_... | go | {
"resource": ""
} |
q22034 | newTorrent | train | func (cl *Client) newTorrent(ih metainfo.Hash, specStorage storage.ClientImpl) (t *Torrent) {
// use provided storage, if provided
storageClient := cl.defaultStorage
if specStorage != nil {
storageClient = storage.NewClient(specStorage)
}
t = &Torrent{
cl: cl,
infoHash: ih,
peers: prioritizedPeers{
... | go | {
"resource": ""
} |
q22035 | AddTorrentInfoHashWithStorage | train | func (cl *Client) AddTorrentInfoHashWithStorage(infoHash metainfo.Hash, specStorage storage.ClientImpl) (t *Torrent, new bool) {
cl.lock()
defer cl.unlock()
t, ok := cl.torrents[infoHash]
if ok {
return
}
new = true
t = cl.newTorrent(infoHash, specStorage)
cl.eachDhtServer(func(s *dht.Server) {
go t.dhtAnn... | go | {
"resource": ""
} |
q22036 | WaitAll | train | func (cl *Client) WaitAll() bool {
cl.lock()
defer cl.unlock()
for !cl.allTorrentsCompleted() {
if cl.closed.IsSet() {
return false
}
cl.event.Wait()
}
return true
} | go | {
"resource": ""
} |
q22037 | Torrents | train | func (cl *Client) Torrents() []*Torrent {
cl.lock()
defer cl.unlock()
return cl.torrentsAsSlice()
} | go | {
"resource": ""
} |
q22038 | publicAddr | train | func (cl *Client) publicAddr(peer net.IP) IpPort {
return IpPort{cl.publicIp(peer), uint16(cl.incomingPeerPort())}
} | go | {
"resource": ""
} |
q22039 | postY | train | func (h *handshake) postY(x *big.Int) error {
var y big.Int
y.Exp(&g, x, &p)
return h.postWrite(paddedLeft(y.Bytes(), 96))
} | go | {
"resource": ""
} |
q22040 | suffixMatchLen | train | func suffixMatchLen(a, b []byte) int {
if len(b) > len(a) {
b = b[:len(a)]
}
// i is how much of b to try to match
for i := len(b); i > 0; i-- {
// j is how many chars we've compared
j := 0
for ; j < i; j++ {
if b[i-1-j] != a[len(a)-1-j] {
goto shorter
}
}
return j
shorter:
}
return 0
} | go | {
"resource": ""
} |
q22041 | readUntil | train | func readUntil(r io.Reader, b []byte) error {
b1 := make([]byte, len(b))
i := 0
for {
_, err := io.ReadFull(r, b1[i:])
if err != nil {
return err
}
i = suffixMatchLen(b1, b)
if i == len(b) {
break
}
if copy(b1, b1[len(b1)-i:]) != i {
panic("wat")
}
}
return nil
} | go | {
"resource": ""
} |
q22042 | fromDictInterface | train | func (p *Peer) fromDictInterface(d map[string]interface{}) {
p.IP = net.ParseIP(d["ip"].(string))
if _, ok := d["peer id"]; ok {
p.ID = []byte(d["peer id"].(string))
}
p.Port = int(d["port"].(int64))
} | go | {
"resource": ""
} |
q22043 | OverridesAnnounce | train | func (al AnnounceList) OverridesAnnounce(announce string) bool {
for _, tier := range al {
for _, url := range tier {
if url != "" || announce == "" {
return true
}
}
}
return false
} | go | {
"resource": ""
} |
q22044 | Add | train | func (me *prioritizedPeers) Add(p Peer) bool {
return me.om.ReplaceOrInsert(prioritizedPeersItem{me.getPrio(p), p}) != nil
} | go | {
"resource": ""
} |
q22045 | defaultPathMaker | train | func defaultPathMaker(baseDir string, info *metainfo.Info, infoHash metainfo.Hash) string {
return baseDir
} | go | {
"resource": ""
} |
q22046 | NewFileWithCustomPathMaker | train | func NewFileWithCustomPathMaker(baseDir string, pathMaker func(baseDir string, info *metainfo.Info, infoHash metainfo.Hash) string) ClientImpl {
return newFileWithCustomPathMakerAndCompletion(baseDir, pathMaker, pieceCompletionForDir(baseDir))
} | go | {
"resource": ""
} |
q22047 | CreateNativeZeroLengthFiles | train | func CreateNativeZeroLengthFiles(info *metainfo.Info, dir string) (err error) {
for _, fi := range info.UpvertedFiles() {
if fi.Length != 0 {
continue
}
name := filepath.Join(append([]string{dir, info.Name}, fi.Path...)...)
os.MkdirAll(filepath.Dir(name), 0777)
var f io.Closer
f, err = os.Create(name)
... | go | {
"resource": ""
} |
q22048 | readFileAt | train | func (fst *fileTorrentImplIO) readFileAt(fi metainfo.FileInfo, b []byte, off int64) (n int, err error) {
f, err := os.Open(fst.fts.fileInfoName(fi))
if os.IsNotExist(err) {
// File missing is treated the same as a short file.
err = io.EOF
return
}
if err != nil {
return
}
defer f.Close()
// Limit the rea... | go | {
"resource": ""
} |
q22049 | ReadAt | train | func (fst fileTorrentImplIO) ReadAt(b []byte, off int64) (n int, err error) {
for _, fi := range fst.fts.info.UpvertedFiles() {
for off < fi.Length {
n1, err1 := fst.readFileAt(fi, b, off)
n += n1
off += int64(n1)
b = b[n1:]
if len(b) == 0 {
// Got what we need.
return
}
if n1 != 0 {
... | go | {
"resource": ""
} |
q22050 | Info | train | func (t *Torrent) Info() *metainfo.Info {
t.cl.lock()
defer t.cl.unlock()
return t.info
} | go | {
"resource": ""
} |
q22051 | NewReader | train | func (t *Torrent) NewReader() Reader {
r := reader{
mu: t.cl.locker(),
t: t,
readahead: 5 * 1024 * 1024,
length: *t.length,
}
t.addReader(&r)
return &r
} | go | {
"resource": ""
} |
q22052 | PieceStateRuns | train | func (t *Torrent) PieceStateRuns() []PieceStateRun {
t.cl.rLock()
defer t.cl.rUnlock()
return t.pieceStateRuns()
} | go | {
"resource": ""
} |
q22053 | PieceBytesMissing | train | func (t *Torrent) PieceBytesMissing(piece int) int64 {
t.cl.lock()
defer t.cl.unlock()
return int64(t.pieces[piece].bytesLeft())
} | go | {
"resource": ""
} |
q22054 | Drop | train | func (t *Torrent) Drop() {
t.cl.lock()
t.cl.dropTorrent(t.infoHash)
t.cl.unlock()
} | go | {
"resource": ""
} |
q22055 | BytesCompleted | train | func (t *Torrent) BytesCompleted() int64 {
t.cl.rLock()
defer t.cl.rUnlock()
return t.bytesCompleted()
} | go | {
"resource": ""
} |
q22056 | Seeding | train | func (t *Torrent) Seeding() bool {
t.cl.lock()
defer t.cl.unlock()
return t.seeding()
} | go | {
"resource": ""
} |
q22057 | SetDisplayName | train | func (t *Torrent) SetDisplayName(dn string) {
t.nameMu.Lock()
defer t.nameMu.Unlock()
if t.haveInfo() {
return
}
t.displayName = dn
} | go | {
"resource": ""
} |
q22058 | Metainfo | train | func (t *Torrent) Metainfo() metainfo.MetaInfo {
t.cl.lock()
defer t.cl.unlock()
return t.newMetaInfo()
} | go | {
"resource": ""
} |
q22059 | DownloadPieces | train | func (t *Torrent) DownloadPieces(begin, end pieceIndex) {
t.cl.lock()
defer t.cl.unlock()
t.downloadPiecesLocked(begin, end)
} | go | {
"resource": ""
} |
q22060 | KnownSwarm | train | func (t *Torrent) KnownSwarm() (ks []Peer) {
// Add pending peers to the list
t.peers.Each(func(peer Peer) {
ks = append(ks, peer)
})
// Add half-open peers to the list
for _, peer := range t.halfOpen {
ks = append(ks, peer)
}
// Add active peers to the list
for conn := range t.conns {
ks = append(ks, ... | go | {
"resource": ""
} |
q22061 | addrActive | train | func (t *Torrent) addrActive(addr string) bool {
if _, ok := t.halfOpen[addr]; ok {
return true
}
for c := range t.conns {
ra := c.remoteAddr
if ra.String() == addr {
return true
}
}
return false
} | go | {
"resource": ""
} |
q22062 | pieceFirstFileIndex | train | func pieceFirstFileIndex(pieceOffset int64, files []*File) int {
for i, f := range files {
if f.offset+f.length > pieceOffset {
return i
}
}
return 0
} | go | {
"resource": ""
} |
q22063 | pieceEndFileIndex | train | func pieceEndFileIndex(pieceEndOffset int64, files []*File) int {
for i, f := range files {
if f.offset+f.length >= pieceEndOffset {
return i + 1
}
}
return 0
} | go | {
"resource": ""
} |
q22064 | setInfoBytes | train | func (t *Torrent) setInfoBytes(b []byte) error {
if metainfo.HashBytes(b) != t.infoHash {
return errors.New("info bytes have wrong hash")
}
var info metainfo.Info
if err := bencode.Unmarshal(b, &info); err != nil {
return fmt.Errorf("error unmarshalling info bytes: %s", err)
}
if err := t.setInfo(&info); err ... | go | {
"resource": ""
} |
q22065 | name | train | func (t *Torrent) name() string {
t.nameMu.RLock()
defer t.nameMu.RUnlock()
if t.haveInfo() {
return t.info.Name
}
return t.displayName
} | go | {
"resource": ""
} |
q22066 | pieceStateRunStatusChars | train | func pieceStateRunStatusChars(psr PieceStateRun) (ret string) {
ret = fmt.Sprintf("%d", psr.Length)
ret += func() string {
switch psr.Priority {
case PiecePriorityNext:
return "N"
case PiecePriorityNormal:
return "."
case PiecePriorityReadahead:
return "R"
case PiecePriorityNow:
return "!"
cas... | go | {
"resource": ""
} |
q22067 | newMetaInfo | train | func (t *Torrent) newMetaInfo() metainfo.MetaInfo {
return metainfo.MetaInfo{
CreationDate: time.Now().Unix(),
Comment: "dynamic metainfo from client",
CreatedBy: "go.torrent",
AnnounceList: t.metainfo.UpvertedAnnounceList(),
InfoBytes: func() []byte {
if t.haveInfo() {
return t.metadataBytes
... | go | {
"resource": ""
} |
q22068 | bytesLeftAnnounce | train | func (t *Torrent) bytesLeftAnnounce() uint64 {
if t.haveInfo() {
return uint64(t.bytesLeft())
} else {
return math.MaxUint64
}
} | go | {
"resource": ""
} |
q22069 | offsetRequest | train | func (t *Torrent) offsetRequest(off int64) (req request, ok bool) {
return torrentOffsetRequest(*t.length, t.info.PieceLength, int64(t.chunkSize), off)
} | go | {
"resource": ""
} |
q22070 | worstBadConn | train | func (t *Torrent) worstBadConn() *connection {
wcs := worseConnSlice{t.unclosedConnsAsSlice()}
heap.Init(&wcs)
for wcs.Len() != 0 {
c := heap.Pop(&wcs).(*connection)
if c.stats.ChunksReadWasted.Int64() >= 6 && c.stats.ChunksReadWasted.Int64() > c.stats.ChunksReadUseful.Int64() {
return c
}
// If the conne... | go | {
"resource": ""
} |
q22071 | updatePiecePriorities | train | func (t *Torrent) updatePiecePriorities(begin, end pieceIndex) {
for i := begin; i < end; i++ {
t.updatePiecePriority(i)
}
} | go | {
"resource": ""
} |
q22072 | byteRegionPieces | train | func (t *Torrent) byteRegionPieces(off, size int64) (begin, end pieceIndex) {
if off >= *t.length {
return
}
if off < 0 {
size += off
off = 0
}
if size <= 0 {
return
}
begin = pieceIndex(off / t.info.PieceLength)
end = pieceIndex((off + size + t.info.PieceLength - 1) / t.info.PieceLength)
if end > piec... | go | {
"resource": ""
} |
q22073 | forReaderOffsetPieces | train | func (t *Torrent) forReaderOffsetPieces(f func(begin, end pieceIndex) (more bool)) (all bool) {
for r := range t.readers {
p := r.pieces
if p.begin >= p.end {
continue
}
if !f(p.begin, p.end) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q22074 | readAt | train | func (t *Torrent) readAt(b []byte, off int64) (n int, err error) {
p := &t.pieces[off/t.info.PieceLength]
p.waitNoPendingWrites()
return p.Storage().ReadAt(b, off-p.Info().Offset())
} | go | {
"resource": ""
} |
q22075 | maybeCompleteMetadata | train | func (t *Torrent) maybeCompleteMetadata() error {
if t.haveInfo() {
// Nothing to do.
return nil
}
if !t.haveAllMetadataPieces() {
// Don't have enough metadata pieces.
return nil
}
err := t.setInfoBytes(t.metadataBytes)
if err != nil {
t.invalidateMetadata()
return fmt.Errorf("error setting info byte... | go | {
"resource": ""
} |
q22076 | bytesCompleted | train | func (t *Torrent) bytesCompleted() int64 {
if !t.haveInfo() {
return 0
}
return t.info.TotalLength() - t.bytesLeft()
} | go | {
"resource": ""
} |
q22077 | deleteConnection | train | func (t *Torrent) deleteConnection(c *connection) (ret bool) {
if !c.closed.IsSet() {
panic("connection is not closed")
// There are behaviours prevented by the closed state that will fail
// if the connection has been deleted.
}
_, ret = t.conns[c]
delete(t.conns, c)
torrent.Add("deleted connections", 1)
c... | go | {
"resource": ""
} |
q22078 | seeding | train | func (t *Torrent) seeding() bool {
cl := t.cl
if t.closed.IsSet() {
return false
}
if cl.config.NoUpload {
return false
}
if !cl.config.Seed {
return false
}
if cl.config.DisableAggressiveUpload && t.needData() {
return false
}
return true
} | go | {
"resource": ""
} |
q22079 | startMissingTrackerScrapers | train | func (t *Torrent) startMissingTrackerScrapers() {
if t.cl.config.DisableTrackers {
return
}
t.startScrapingTracker(t.metainfo.Announce)
for _, tier := range t.metainfo.AnnounceList {
for _, url := range tier {
t.startScrapingTracker(url)
}
}
} | go | {
"resource": ""
} |
q22080 | announceRequest | train | func (t *Torrent) announceRequest() tracker.AnnounceRequest {
// Note that IPAddress is not set. It's set for UDP inside the tracker
// code, since it's dependent on the network in use.
return tracker.AnnounceRequest{
Event: tracker.None,
NumWant: -1,
Port: uint16(t.cl.incomingPeerPort()),
PeerId: ... | go | {
"resource": ""
} |
q22081 | consumeDhtAnnouncePeers | train | func (t *Torrent) consumeDhtAnnouncePeers(pvs <-chan dht.PeersValues) {
cl := t.cl
for v := range pvs {
cl.lock()
for _, cp := range v.Peers {
if cp.Port == 0 {
// Can't do anything with this.
continue
}
t.addPeer(Peer{
IP: cp.IP[:],
Port: cp.Port,
Source: peerSourceDHTGetPeers,... | go | {
"resource": ""
} |
q22082 | numTotalPeers | train | func (t *Torrent) numTotalPeers() int {
peers := make(map[string]struct{})
for conn := range t.conns {
ra := conn.conn.RemoteAddr()
if ra == nil {
// It's been closed and doesn't support RemoteAddr.
continue
}
peers[ra.String()] = struct{}{}
}
for addr := range t.halfOpen {
peers[addr] = struct{}{}
... | go | {
"resource": ""
} |
q22083 | reconcileHandshakeStats | train | func (t *Torrent) reconcileHandshakeStats(c *connection) {
if c.stats != (ConnStats{
// Handshakes should only increment these fields:
BytesWritten: c.stats.BytesWritten,
BytesRead: c.stats.BytesRead,
}) {
panic("bad stats")
}
c.postHandshakeStats(func(cs *ConnStats) {
cs.BytesRead.Add(c.stats.BytesRea... | go | {
"resource": ""
} |
q22084 | addConnection | train | func (t *Torrent) addConnection(c *connection) (err error) {
defer func() {
if err == nil {
torrent.Add("added connections", 1)
}
}()
if t.closed.IsSet() {
return errors.New("torrent closed")
}
for c0 := range t.conns {
if c.PeerID != c0.PeerID {
continue
}
if !t.cl.config.dropDuplicatePeerIds {
... | go | {
"resource": ""
} |
q22085 | onIncompletePiece | train | func (t *Torrent) onIncompletePiece(piece pieceIndex) {
if t.pieceAllDirty(piece) {
t.pendAllChunkSpecs(piece)
}
if !t.wantPieceIndex(piece) {
// t.logger.Printf("piece %d incomplete and unwanted", piece)
return
}
// We could drop any connections that we told we have a piece that we
// don't here. But there... | go | {
"resource": ""
} |
q22086 | reapPieceTouchers | train | func (t *Torrent) reapPieceTouchers(piece pieceIndex) (ret []*connection) {
for c := range t.pieces[piece].dirtiers {
delete(c.peerTouchedPieces, piece)
ret = append(ret, c)
}
t.pieces[piece].dirtiers = nil
return
} | go | {
"resource": ""
} |
q22087 | queuePieceCheck | train | func (t *Torrent) queuePieceCheck(pieceIndex pieceIndex) {
piece := &t.pieces[pieceIndex]
if piece.queuedForHash() {
return
}
t.piecesQueuedForHash.Add(bitmap.BitIndex(pieceIndex))
t.publishPieceChange(pieceIndex)
t.updatePiecePriority(pieceIndex)
go t.verifyPiece(pieceIndex)
} | go | {
"resource": ""
} |
q22088 | initiateConn | train | func (t *Torrent) initiateConn(peer Peer) {
if peer.Id == t.cl.peerID {
return
}
if t.cl.badPeerIPPort(peer.IP, peer.Port) {
return
}
addr := IpPort{peer.IP, uint16(peer.Port)}
if t.addrActive(addr.String()) {
return
}
t.halfOpen[addr.String()] = peer
go t.cl.outgoingConnection(t, addr, peer.Source)
} | go | {
"resource": ""
} |
q22089 | allStats | train | func (t *Torrent) allStats(f func(*ConnStats)) {
f(&t.stats)
f(&t.cl.stats)
} | go | {
"resource": ""
} |
q22090 | BuildFromFilePath | train | func (info *Info) BuildFromFilePath(root string) (err error) {
info.Name = filepath.Base(root)
info.Files = nil
err = filepath.Walk(root, func(path string, fi os.FileInfo, err error) error {
if err != nil {
return err
}
if fi.IsDir() {
// Directories are implicit in torrent files.
return nil
} else ... | go | {
"resource": ""
} |
q22091 | writeFiles | train | func (info *Info) writeFiles(w io.Writer, open func(fi FileInfo) (io.ReadCloser, error)) error {
for _, fi := range info.UpvertedFiles() {
r, err := open(fi)
if err != nil {
return fmt.Errorf("error opening %v: %s", fi, err)
}
wn, err := io.CopyN(w, r, fi.Length)
r.Close()
if wn != fi.Length {
return... | go | {
"resource": ""
} |
q22092 | UpvertedFiles | train | func (info *Info) UpvertedFiles() []FileInfo {
if len(info.Files) == 0 {
return []FileInfo{{
Length: info.Length,
// Callers should determine that Info.Name is the basename, and
// thus a regular file.
Path: nil,
}}
}
return info.Files
} | go | {
"resource": ""
} |
q22093 | makeStoredLabels | train | func makeStoredLabels(labels []string) map[string]string {
storedLabels := make(map[string]string)
for _, s := range labels {
split := strings.SplitN(s, "=", 2)
if len(split) == 1 {
storedLabels[split[0]] = split[0]
} else {
storedLabels[split[1]] = split[0]
}
}
return storedLabels
} | go | {
"resource": ""
} |
q22094 | makeIgnoredLabels | train | func makeIgnoredLabels(labels []string) map[string]string {
ignoredLabels := make(map[string]string)
for _, s := range labels {
ignoredLabels[s] = ""
}
return ignoredLabels
} | go | {
"resource": ""
} |
q22095 | NewLabelCopier | train | func NewLabelCopier(separator string, storedLabels, ignoredLabels []string) (*LabelCopier, error) {
return &LabelCopier{
labelSeparator: separator,
storedLabels: makeStoredLabels(storedLabels),
ignoredLabels: makeIgnoredLabels(ignoredLabels),
}, nil
} | go | {
"resource": ""
} |
q22096 | getEventValue | train | func getEventValue(event *kube_api.Event) (string, error) {
// TODO: check whether indenting is required.
bytes, err := json.MarshalIndent(event, "", " ")
if err != nil {
return "", err
}
return string(bytes), nil
} | go | {
"resource": ""
} |
q22097 | newSink | train | func newSink(c influxdb_common.InfluxdbConfig) core.EventSink {
client, err := influxdb_common.NewClient(c)
if err != nil {
glog.Errorf("issues while creating an InfluxDB sink: %v, will retry on use", err)
}
return &influxdbSink{
client: client, // can be nil
c: c,
}
} | go | {
"resource": ""
} |
q22098 | metricToPoint | train | func (tsdbSink *openTSDBSink) metricToPoint(name string, value core.MetricValue, timestamp time.Time, labels map[string]string) opentsdbclient.DataPoint {
seriesName := strings.Replace(toValidOpenTsdbName(name), "/", "_", -1)
if value.MetricType.String() != "" {
seriesName = fmt.Sprintf("%s_%s", seriesName, value.... | go | {
"resource": ""
} |
q22099 | putDefaultTags | train | func (tsdbSink *openTSDBSink) putDefaultTags(datapoint *opentsdbclient.DataPoint) {
datapoint.Tags[clusterNameTagName] = tsdbSink.clusterName
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.