id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c174000 |
_, err := c.MakeApiRequest("GET", "/1.0/api_clients/"+identifier, nil, apiClient)
if err != nil {
return nil, err
}
return apiClient, err
} | |
c174001 | c.MakeApiRequest("POST", "/1.0/api_clients/"+identifier+"/reset_secret", nil, &ac)
if err != nil {
return nil, err
}
return ac, nil
} | |
c174002 |
if err != nil {
return nil, err
}
return images, err
} | |
c174003 | image)
if err != nil {
return nil, err
}
return image, err
} | |
c174004 | &accounts)
if err != nil {
return nil, err
}
return accounts, err
} | |
c174005 | nil, account)
if err != nil {
return nil, err
}
return account, err
} | |
c174006 |
if err != nil {
return nil, err
}
return cloudips, err
} | |
c174007 | nil, cloudip)
if err != nil {
return nil, err
}
return cloudip, err
} | |
c174008 | identifier)
}
destination := server.Interfaces[0].Id
err = c.MapCloudIP(identifier, destination)
if err != nil {
return err
}
return nil
} | |
c174009 | r.Header.Set("X-Auth-Token", t.AccessToken)
} | |
c174010 |
resp, err := c.Request("GET", getURL(c), &gophercloud.RequestOpts{
MoreHeaders: h,
OkCodes: []int{200},
})
if resp != nil {
r.Header = resp.Header
}
r.Err = err
return r
} | |
c174011 | "/1.0/user/collaborations", nil, &cl)
if err != nil {
return nil, err
}
return cl, err
} | |
c174012 | c.MakeApiRequest("GET", "/1.0/user/collaborations/"+identifier, nil, col)
if err != nil {
return nil, err
}
return col, err
} | |
c174013 |
_, err := c.MakeApiRequest("GET", "/1.0/database_snapshots", nil, &database_snapshot)
if err != nil {
return nil, err
}
return database_snapshot, err
} | |
c174014 |
_, err := c.MakeApiRequest("GET", "/1.0/database_snapshots/"+identifier, nil, database_snapshot)
if err != nil {
return nil, err
}
return database_snapshot, err
} | |
c174015 | go ping(pingChan, pongChan, d.PingOptions...)
}
go receivePong(len(hostsInCidr), pongChan, doneChan)
for _, ip := range hostsInCidr {
pingChan <- ip
}
alives := <-doneChan
for _, a := range alives {
aliveIPs = append(aliveIPs, a.IP)
}
sort.Strings(aliveIPs)
return
} | |
c174016 | // #nosec
_ = os.Remove(f.Name()) // #nosec
return errors.Wrap(err, "failed to download")
}
err = f.Close()
if err != nil {
_ = os.Remove(f.Name()) // #nosec
return errors.Wrap(err, "failed to close temp file")
}
if err = renameFile(f.Name(), dest); err != nil {
return err
}
return nil
} | |
c174017 | return errors.Wrap(err, "invalid src URL")
}
return FromURL(u, w, options)
} | |
c174018 | options.RetryInterval); err != nil {
return errors.Wrap(err, "download failed")
}
defer func() { _ = resp.Body.Close() }() // #nosec
var (
validator checksumValidator
reader io.Reader = resp.Body
)
if options.ProgressBars != nil && resp.ContentLength > 0 {
bar := newProgressBar(resp.ContentLength, options.ProgressBars.MaxWidth, options.ProgressBars.Writer)
bar.Start()
reader = bar.NewProxyReader(reader)
defer func() {
<-time.After(bar.RefreshRate)
fmt.Println()
}()
}
validator, reader, err = createValidatorReader(reader, options.ChecksumHash, httpClient, options.Checksum, path.Base(src.Path))
if err != nil {
return err
}
if _, err = io.Copy(w, reader); err != nil {
return errors.Wrap(err, "failed to copy contents")
}
if !validator.validate() {
return errors.New("checksum validation failed")
}
return nil
} | |
c174019 | offset := int(digest[19] & 0xf)
code := int32(digest[offset]&0x7f)<<24 |
int32(digest[offset+1]&0xff)<<16 |
int32(digest[offset+2]&0xff)<<8 |
int32(digest[offset+3]&0xff)
code = int32(int64(code) % int64(math.Pow10(totp.Digits)))
return code
} | |
c174020 | reverse that encoding...
label = url.QueryEscape(label)
label = strings.Replace(label, "+", " ", -1)
return fmt.Sprintf("otpauth://totp/%v?secret=%v&Digits=%v&Period=%v", label, totp.Secret(), totp.Digits, totp.Period)
} | |
c174021 | make([]byte, length)
for i, _ := range secret {
secret[i] = byte(rnd.Int31() % 256)
}
return base32.StdEncoding.EncodeToString(secret)
} | |
c174022 | DefaultMConnConfig(),
Fuzz: false,
FuzzConfig: DefaultFuzzConnConfig(),
}
} | |
c174023 | panic("Attempt to get peer's PubKey before calling Handshake")
}
return p.PubKey()
} | |
c174024 | p.mconn.Start()
return err
} | |
c174025 | peer may be removed and stopped.
return false
}
return p.mconn.Send(chID, msg)
} | |
c174026 | int
wire.WriteString(p.Key, w, &n_, &err)
n += int64(n_)
return
} | |
c174027 | p.Key == other.Key
} | |
c174028 | {
return FuzzConnAfterFromConfig(conn, d, DefaultFuzzConnConfig())
} | |
c174029 | onReceive: onReceive,
onError: onError,
config: config,
LocalAddress: NewNetAddress(conn.LocalAddr()),
RemoteAddress: NewNetAddress(conn.RemoteAddr()),
}
// Create channels
var channelsIdx = map[byte]*Channel{}
var channels = []*Channel{}
for _, desc := range chDescs {
descCopy := *desc // copy the desc else unsafe access across connections
channel := newChannel(mconn, &descCopy)
channelsIdx[channel.id] = channel
channels = append(channels, channel)
}
mconn.channels = channels
mconn.channelsIdx = channelsIdx
mconn.BaseService = *cmn.NewBaseService(log, "MConnection", mconn)
return mconn
} | |
c174030 | := cmn.StackError{r, stack}
c.stopForError(err)
}
} | |
c174031 | !ok {
log.Error(cmn.Fmt("Cannot send bytes, unknown channel %X", chID))
return false
}
success := channel.sendBytes(wire.BinaryBytes(msg))
if success {
// Wake up sendRoutine if necessary
select {
case c.send <- struct{}{}:
default:
}
} else {
log.Warn("Send failed", "channel", chID, "conn", c, "msg", msg)
}
return success
} | |
c174032 | return false
}
ok = channel.trySendBytes(wire.BinaryBytes(msg))
if ok {
// Wake up sendRoutine if necessary
select {
case c.send <- struct{}{}:
default:
}
}
return ok
} | |
c174033 | log.Error(cmn.Fmt("Unknown channel %X", chID))
return false
}
return channel.canSend()
} | |
c174034 | case <-c.quit:
break FOR_LOOP
case <-c.send:
// Send some msgPackets
eof := c.sendSomeMsgPackets()
if !eof {
// Keep sendRoutine awake.
select {
case c.send <- struct{}{}:
default:
}
}
}
if !c.IsRunning() {
break FOR_LOOP
}
if err != nil {
log.Warn("Connection failed @ sendRoutine", "conn", c, "error", err)
c.stopForError(err)
break FOR_LOOP
}
}
// Cleanup
} | |
c174035 |
// Now send some msgPackets.
for i := 0; i < numBatchMsgPackets; i++ {
if c.sendMsgPacket() {
return true
}
}
return false
} | |
c174036 | lowest ratio.
ratio := float32(channel.recentlySent) / float32(channel.priority)
if ratio < leastRatio {
leastRatio = ratio
leastChannel = channel
}
}
// Nothing to send?
if leastChannel == nil {
return true
} else {
// log.Info("Found a msgPacket to send")
}
// Make & send a msgPacket from this channel
n, err := leastChannel.writeMsgPacketTo(c.bufWriter)
if err != nil {
log.Warn("Failed to write msgPacket", "error", err)
c.stopForError(err)
return true
}
c.sendMonitor.Update(int(n))
c.flushTimer.Set()
return false
} | |
c174037 | decrement sendQueueSize
} else {
packet.EOF = byte(0x00)
ch.sending = ch.sending[cmn.MinInt(maxMsgPacketPayloadSize, len(ch.sending)):]
}
return packet
} | |
c174038 |
wire.WriteBinary(packet, w, &n, &err)
if err == nil {
ch.recentlySent += int64(n)
}
return
} | |
c174039 | the memory for the channel until it closes,
// at which point the recving slice stops being used and should be garbage collected
ch.recving = ch.recving[:0] // make([]byte, 0, ch.desc.RecvBufferCapacity)
return msgBytes, nil
}
return nil, nil
} | |
c174040 | // does not error
resSlice := hasher.Sum(nil)
res = new([24]byte)
copy(res[:], resSlice)
return
} | |
c174041 | 1
if nonce[i] != 0 {
return
}
}
} | |
c174042 | ps.mtx.Lock()
defer ps.mtx.Unlock()
return ps.list
} | |
c174043 |
PanicCrisis(err)
}
l.connections <- conn
}
// Cleanup
close(l.connections)
for _ = range l.connections {
// Drain
}
} | |
c174044 | make(map[string]*NetAddress),
addrLookup: make(map[string]*knownAddress),
filePath: filePath,
routabilityStrict: routabilityStrict,
}
am.init()
am.BaseService = *NewBaseService(log, "AddrBook", am)
return am
} | |
c174045 |
a.loadFromFile(a.filePath)
a.wg.Add(1)
go a.saveRoutine()
return nil
} | |
c174046 | return
}
log.Info("Remove address from book", "addr", addr)
a.removeFromAllBuckets(ka)
} | |
c174047 | aJSON.Key
// Restore .addrNew & .addrOld
for _, ka := range aJSON.Addrs {
for _, bucketIndex := range ka.Buckets {
bucket := a.getBucket(ka.BucketType, bucketIndex)
bucket[ka.Addr.String()] = ka
}
a.addrLookup[ka.Addr.String()] = ka
if ka.BucketType == bucketTypeNew {
a.nNew++
} else {
a.nOld++
}
}
return true
} | |
c174048 | a.Size())
a.saveToFile(a.filePath)
} | |
c174049 | }
// Enforce max addresses.
if len(bucket) > oldBucketSize {
return false
}
// Add to bucket.
bucket[addrStr] = ka
if ka.addBucketRef(bucketIdx) == 1 {
a.nOld++
}
// Ensure in addrLookup
a.addrLookup[addrStr] = ka
return true
} | |
c174050 |
// If we haven't thrown out a bad entry, throw out the oldest entry
oldest := a.pickOldest(bucketTypeNew, bucketIdx)
a.removeFromBucket(oldest, bucketTypeNew, bucketIdx)
} | |
c174051 |
addrBook.Save()
}
// permute the list, dial them in random order.
perm := rand.Perm(len(netAddrs))
for i := 0; i < len(perm); i++ {
go func(i int) {
time.Sleep(time.Duration(rand.Int63n(3000)) * time.Millisecond)
j := perm[i]
sw.dialSeed(netAddrs[j])
}(i)
}
return nil
} | |
c174052 | return nil, errors.New(cmn.Fmt("Error in address %s: %v", addr, err))
}
netAddrs[i] = netAddr
}
return netAddrs, nil
} | |
c174053 | ip,
Port: port,
str: net.JoinHostPort(
ip.String(),
strconv.FormatUint(uint64(port), 10),
),
}
return na
} | |
c174054 | ok := other.(*NetAddress); ok {
return na.String() == o.String()
}
return false
} | |
c174055 | := net.Dial("tcp", na.String())
if err != nil {
return nil, err
}
return conn, nil
} | |
c174056 | && !(na.IP.IsUnspecified() || na.RFC3849() ||
na.IP.Equal(net.IPv4bcast))
} | |
c174057 | return Ipv6_weak
}
} else if na.IP.To4() != nil {
if o.Routable() && o.IP.To4() != nil {
return Ipv4
}
return Default
} else /* ipv6 */ {
var tunnelled bool
// Is our v6 is tunnelled?
if o.RFC3964() || o.RFC6052() || o.RFC6145() {
tunnelled = true
}
if !o.Routable() {
return Default
} else if o.RFC4380() {
return Teredo
} else if o.IP.To4() != nil {
return Ipv4
} else if tunnelled {
// only prioritise ipv6 if we aren't tunnelling it.
return Ipv6_weak
}
return Ipv6_strong
}
} | |
c174058 | maxMsgCountByPeer: defaultMaxMsgCountByPeer,
}
r.BaseReactor = *NewBaseReactor(log, "PEXReactor", r)
return r
} | |
c174059 | r.ensurePeersRoutine()
go r.flushMsgCountByPeer()
return nil
} | |
c174060 | src requested some peers.
r.SendAddrs(src, r.book.GetSelection())
case *pexAddrsMessage:
// We received some peer addresses from src.
// (We don't want to get spammed with bad peers)
for _, addr := range msg.Addrs {
if addr != nil {
r.book.AddAddress(addr, srcAddr)
}
}
default:
log.Warn(fmt.Sprintf("Unknown message type %v", reflect.TypeOf(msg)))
}
} | |
c174061 | PexMessage }{&pexRequestMessage{}})
} | |
c174062 | PexMessage }{&pexAddrsMessage{Addrs: addrs}})
} | |
c174063 | count = countI.(uint16)
}
count++
r.msgCountByPeer.Set(addr, count)
} | |
c174064 | }{}, r, maxPexMessageSize, n, &err).(struct{ PexMessage }).PexMessage
return
} | |
c174065 |
Reader: csv.NewReader(r),
}
} | |
c174066 | logMutex.Unlock()
log.Printf("panic=%016x message=%v\n", id, err)
for _, line := range stacktrace {
log.Printf("panic=%016x %s", id, line)
}
} | |
c174067 | &recoveryHandler{h: h, p: onPanic}
} | |
c174068 | s := range al.buffer {
fmt.Fprint(al.w, s)
}
close(al.quit)
}()
} | |
c174069 | ),
),
onPanic,
),
os.Stdout,
)
l.Start()
return Service{h: l}
} | |
c174070 |
v.InvalidHandler.ServeHTTP(w, r)
} else {
log.Printf("Rejected request with an invalid client certificate: %q", dn)
w.WriteHeader(403)
}
})
} | |
c174071 | }
// TODO only primitive types
return fmt.Sprintf("%s", val)
}
return defval
} | |
c174072 | := strconv.Atoi(s)
if err != nil {
// TODO handling error on app level
return defval
}
return i
}
}
return defval
} | |
c174073 |
log.Info("registered pubsub driver: %v", knownNames)
} | |
c174074 | conn: conn,
redisURL: redisURL,
subs: make(map[*sub]struct{}),
}, nil
} | |
c174075 | ok = msg.([]byte)
if !ok {
data, err = json.Marshal(msg)
if err != nil {
// TODO should we ignore error messages?
log.Error("json.Marshal failed with: %+v", err)
continue
}
}
if len(data) == 0 {
log.Warning("empty message is not allowed")
continue
}
send <- data
// listen to connection close and un-register message channel
case <-sub.CloseNotify():
log.Info("subscription closed")
stop()
return
case <-closeConn:
stop()
return
case <-heartbeatTicker.C:
send <- heatbeat
}
}
}()
for {
var data, ok = <-send
if !ok {
log.Info("connection closed, stop streaming of %v", channels)
return
}
if len(data) == 0 {
fmt.Fprint(w, ":heartbeat signal\n\n")
} else {
fmt.Fprintf(w, "data: %s\n\n", data)
}
flusher.Flush()
}
} | |
c174076 | log.Errorf("json.Unmarshal failed: %+v", err)
return nil, err
}
return msg, nil
} | |
c174077 |
var cn = hub.getChannel(name)
cn.Publish(msg)
}
} | |
c174078 | }
var sub = makeSub(chans)
for _, cn := range chans {
cn.Subscribe(sub)
}
return sub, nil
} | |
c174079 | := hub.channels[name]
if ok {
return cn
}
cn = makeChannel(hub, name)
hub.channels[name] = cn
go cn.start()
return cn
} | |
c174080 |
return
}
delete(hub.channels, cn.name)
return
} | |
c174081 | return nil, err
}
return &hub{
conn: conn,
subs: make(map[*sub]struct{}),
}, nil
} | |
c174082 | to %v", channels)
hubInstance.Publish(channels, msg)
return nil
} | |
c174083 | log.Errorf("pubsub subscribe failed: %+v", err)
return nil, err
}
log.Debug("subscibe to %v", channels)
return r, nil
} | |
c174084 |
d, ok := drivers[driverName]
if ok {
h, err := d.Create(config)
if err != nil {
log.Errorf("unable to connect to %s pubsub server: %+v", driverName, err)
return nil, err
}
log.Info("connected to %s pubsub", driverName)
return h, nil
}
return nil, fmt.Errorf("unknown driver: %s", driverName)
} | |
c174085 |
return time.Duration(a*10) * time.Millisecond
}
} | |
c174086 | = start + i
} else {
result[i] = int(math.Abs(float64(max - (start + i))))
}
}
return result
} | |
c174087 |
return "", errors.New("cannot find user-specific home dir")
}
return currentUser.HomeDir, nil
} | |
c174088 |
ErrStatusNotOK.origin = fmt.Sprintf("status code %d", resp.StatusCode)
return "", ErrStatusNotOK
}
}
if err := json.NewDecoder(resp.Body).Decode(&s.Decoded); err != nil {
ErrInvalidJSON.origin = err.Error()
return "", ErrInvalidJSON
}
if _, ok := s.Decoded["output"].(string); !ok {
return "", fmt.Errorf("Cleverbot API: 'output' does not exist or is not a string")
}
if _, ok := s.Decoded["cs"].(string); !ok {
return "", fmt.Errorf("Cleverbot API: 'cs' does not exist or is not a string")
}
// Set session context id.
s.Values.Set("cs", s.Decoded["cs"].(string))
return s.Decoded["output"].(string), nil
} | |
c174089 | strconv.Atoi(v); err == nil {
return count
}
}
return -1
} | |
c174090 | ok {
if dur, err := time.ParseDuration(v + "s"); err == nil {
return dur
}
}
return time.Second * -1
} | |
c174091 | qa = append([]QAPair{{s.Decoded[fmt.Sprintf("interaction_%d", i)].(string),
s.Decoded[fmt.Sprintf("interaction_%d_other", i)].(string)}}, qa...)
} else {
return qa
}
}
} | |
c174092 | bool {
return f.C.Bool(name)
} | |
c174093 | string {
return f.C.String(name)
} | |
c174094 | t.mu.Unlock()
t.failed = true
} | |
c174095 | t.mu.Unlock()
return t.failed
} | |
c174096 | ...interface{}) {
fmt.Printf(format, args...)
} | |
c174097 | fmt.Fprintln(os.Stderr, args...)
t.Fail()
} | |
c174098 | fmt.Fprintf(os.Stderr, format, args...)
t.Fail()
} | |
c174099 | new(f)
}
c.api = api
c.Url = root
c.Auth = auth
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.