id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c179200 | map[mesh.PeerName]int{},
self: self,
}
} | |
c179201 | st.mergeComplete(other.(*state).copy().set)
} | |
c179202 | forwarded data smaller
continue
}
st.set[peer] = v
}
return &state{
set: set, // all remaining elements were novel to us
}
} | |
c179203 | st.set[peer] = v
}
}
return &state{
set: st.set, // n.b. can't .copy() due to lock contention
}
} | |
c179204 | {
return newSurrogateGossipData(update), nil
} | |
c179205 | time)
updateTime := now()
deleteBefore := updateTime.Add(-gossipInterval)
keepFrom := len(s.prevUpdates)
for i, p := range s.prevUpdates {
if p.t.After(deleteBefore) {
keepFrom = i
break
}
}
s.prevUpdates = append(s.prevUpdates[keepFrom:], prevUpdate{update, updateHash, updateTime})
return newSurrogateGossipData(update), nil
} | |
c179206 |
return box.GenerateKey(rand.Reader)
} | |
c179207 | append(sharedKeySlice, secretKey...)
sessionKey := sha256.Sum256(sharedKeySlice)
return &sessionKey
} | |
c179208 | s.nonce[0] |= (1 << 7)
}
s.nonce[0] |= (1 << 6)
return s
} | |
c179209 | return sender.encoder.Encode(msg)
} | |
c179210 | this thread-safe without locking.
prefixedMsg := make([]byte, 4+l)
binary.BigEndian.PutUint32(prefixedMsg, uint32(l))
copy(prefixedMsg[4:], msg)
_, err := sender.writer.Write(prefixedMsg)
return err
} | |
c179211 | sender.state.sessionKey)
sender.state.advance()
return sender.sender.Send(encodedMsg)
} | |
c179212 | {
var msg []byte
err := receiver.decoder.Decode(&msg)
return msg, err
} | |
c179213 | fmt.Errorf("incoming message exceeds maximum size: %d > %d", l, maxTCPMsgSize)
}
msg := make([]byte, l)
_, err := io.ReadFull(receiver.reader, msg)
return msg, err
} | |
c179214 | {
return nil, fmt.Errorf("Unable to decrypt TCP msg")
}
receiver.state.advance()
return decodedMsg, nil
} | |
c179215 | actions,
quit: make(chan struct{}),
logger: logger,
}
go p.loop(actions)
return p
} | |
c179216 | sender configured; not broadcasting update right now")
}
result = st.get()
}
<-c
return result
} | |
c179217 | complete %v", complete.(*state).set)
return complete
} | |
c179218 | }
complete := p.st.mergeComplete(set)
p.logger.Printf("OnGossipUnicast %s %v => complete %v", src, set, complete)
return nil
} | |
c179219 |
ID: uint64(addr.(meshconn.MeshAddr).PeerUID),
Context: nil, // TODO(pb): ??
}
} | |
c179220 | return fmt.Sprint(peer.Name, "(", peer.NickName, ")")
} | |
c179221 | {
continue
}
if _, found := exclude[remoteName]; found {
continue
}
remotePeer := conn.Remote()
if remoteConn, found := remotePeer.connections[peer.Name]; !establishedAndSymmetric || (found && remoteConn.isEstablished()) {
f(remotePeer)
}
}
} | |
c179222 | strconv.ParseUint(s, 10, 64)
return PeerUID(uid), err
} | |
c179223 | lop[i], lop[j] = lop[j], lop[i]
} | |
c179224 | return lop[i].Name < lop[j].Name
} | |
c179225 | return
}
if err = params.Conn.SetReadDeadline(time.Now().Add(tcpHeartbeat * 2)); err != nil {
return
}
switch res.Version {
case 1:
err = res.doIntroV1(params, pubKey, privKey)
case 2:
err = res.doIntroV2(params, pubKey, privKey)
default:
panic("unhandled protocol version")
}
return
} | |
c179226 | if val, ok := intro[k]; ok {
safe[k] = val
}
}
return safe
} | |
c179227 | discovery: discovery,
directPeers: peerAddrs{},
targets: make(map[string]*target),
connections: make(map[Connection]struct{}),
actionChan: actionChan,
logger: logger,
}
go cm.queryLoop(actionChan)
return cm
} | |
c179228 | target.state = targetWaiting
target.lastError = err
target.nextTryLater()
return true
}
} | |
c179229 | sender,
broadcasts: make(map[PeerName]GossipData),
more: more,
flush: flush,
}
go s.run(stop, more, flush)
return s
} | |
c179230 |
defer s.prod()
}
if s.gossip == nil {
s.gossip = data
} else {
s.gossip = s.gossip.Merge(data)
}
} | |
c179231 | s.broadcasts[srcName] = data
} else {
s.broadcasts[srcName] = d.Merge(data)
}
} | |
c179232 | bool)
s.flush <- ch
return <-ch
} | |
c179233 | found := gs.senders[channelName]
if !found {
s = makeGossipSender(gs.sender, gs.stop)
gs.senders[channelName] = s
}
return s
} | |
c179234 | gs.Unlock()
for _, sender := range gs.senders {
sent = sender.Flush() || sent
}
return sent
} | |
c179235 | "main.main" || frame.Function == "testing.tRunner" {
return frame.File
}
if !more {
break
}
}
return ""
} | |
c179236 | = internal.Call(c, service, "CreateChannel", req, resp)
token = resp.GetToken()
return token, remapError(err)
} | |
c179237 |
return remapError(internal.Call(c, service, "SendChannelMessage", req, resp))
} | |
c179238 | != nil {
return err
}
return Send(c, clientID, string(m))
} | |
c179239 |
e.Service = "channel"
}
}
return err
} | |
c179240 | return withNamespace(ctx, namespace)
} | |
c179241 | p.Value,
Flags: p.GetFlags(),
casID: p.GetCasId(),
}
} | |
c179242 | ok {
return me[0]
}
return err
} | |
c179243 | m[key]; !ok {
return nil, ErrCacheMiss
}
return m[key], nil
} | |
c179244 | if err := internal.Call(c, "memcache", "Get", req, res); err != nil {
return nil, err
}
m := make(map[string]*Item, len(res.Item))
for _, p := range res.Item {
t := protoToItem(p)
m[t.Key] = t
}
return m, nil
} | |
c179245 | singleError(DeleteMulti(c, []string{key}))
} | |
c179246 | for i, s := range res.DeleteStatus {
switch s {
case pb.MemcacheDeleteResponse_DELETED:
// OK
case pb.MemcacheDeleteResponse_NOT_FOUND:
me[i] = ErrCacheMiss
any = true
default:
me[i] = ErrServerError
any = true
}
}
if any {
return me
}
return nil
} | |
c179247 | error) {
return incr(c, key, delta, &initialValue)
} | |
c179248 | err error) {
return incr(c, key, delta, nil)
} | |
c179249 |
// Because an Expiration of 0 means no expiration, we take
// care here to translate an item with an expiration
// Duration between 0-1 seconds as immediately expiring
// (saying it expired a few seconds ago), rather than
// rounding it down to 0 and making it live forever.
p.ExpirationTime = proto.Uint32(uint32(time.Now().Unix()) - 5)
} else if t.Expiration >= thirtyYears {
p.ExpirationTime = proto.Uint32(uint32(time.Now().Unix()) + uint32(t.Expiration/time.Second))
} else {
p.ExpirationTime = proto.Uint32(uint32(t.Expiration / time.Second))
}
}
if t.casID != 0 {
p.CasId = proto.Uint64(t.casID)
p.ForCas = proto.Bool(true)
}
p.SetPolicy = policy.Enum()
req.Item[i] = p
}
res := &pb.MemcacheSetResponse{}
if err := internal.Call(c, "memcache", "Set", req, res); err != nil {
return err
}
if len(res.SetStatus) != len(item) {
return ErrServerError
}
me, any := make(appengine.MultiError, len(item)), false
for i, st := range res.SetStatus {
var err error
switch st {
case pb.MemcacheSetResponse_STORED:
// OK
case pb.MemcacheSetResponse_NOT_STORED:
err = ErrNotStored
case pb.MemcacheSetResponse_EXISTS:
err = ErrCASConflict
default:
err = ErrServerError
}
if err != nil {
me[i] = err
any = true
}
}
if any {
return me
}
return nil
} | |
c179250 | := cd.Unmarshal(i.Value, v); err != nil {
return nil, err
}
return i, nil
} | |
c179251 | err
}
if res.Stats == nil {
return nil, ErrNoStats
}
return &Statistics{
Hits: *res.Stats.Hits,
Misses: *res.Stats.Misses,
ByteHits: *res.Stats.ByteHits,
Items: *res.Stats.Items,
Bytes: *res.Stats.Bytes,
Oldest: int64(*res.Stats.OldestItemAge),
}, nil
} | |
c179252 |
return internal.Call(c, "memcache", "FlushAll", req, res)
} | |
c179253 | internal.Call(c, "system", "StartBackgroundRequest", req, res); err != nil {
return err
}
sendc <- send{res.GetRequestId(), f}
return nil
} | |
c179254 |
res := &pb.GetModulesResponse{}
err := internal.Call(c, "modules", "GetModules", req, res)
return res.Module, err
} | |
c179255 | req.Instances = proto.Int64(int64(instances))
res := &pb.SetNumInstancesResponse{}
return internal.Call(c, "modules", "SetNumInstances", req, res)
} | |
c179256 | "" {
req.Module = &module
}
res := &pb.GetVersionsResponse{}
err := internal.Call(c, "modules", "GetVersions", req, res)
return res.GetVersion(), err
} | |
c179257 | "" {
req.Module = &module
}
res := &pb.GetDefaultVersionResponse{}
err := internal.Call(c, "modules", "GetDefaultVersion", req, res)
return res.GetVersion(), err
} | |
c179258 |
}
res := &pb.StartModuleResponse{}
return internal.Call(c, "modules", "StartModule", req, res)
} | |
c179259 | }
res := &pb.StopModuleResponse{}
return internal.Call(c, "modules", "StopModule", req, res)
} | |
c179260 | query ancestor")
return q
}
q.ancestor = ancestor
return q
} | |
c179261 | *Query {
q = q.clone()
q.eventual = true
return q
} | |
c179262 |
q = q.clone()
q.projection = append([]string(nil), fieldNames...)
return q
} | |
c179263 | q.clone()
q.distinct = true
return q
} | |
c179264 | *Query {
q = q.clone()
q.distinctOn = fieldNames
return q
} | |
c179265 | q.clone()
q.keysOnly = true
return q
} | |
c179266 | limit overflow")
return q
}
q.limit = int32(limit)
return q
} | |
c179267 | errors.New("datastore: query offset overflow")
return q
}
q.offset = int32(offset)
return q
} | |
c179268 | size overflow")
return q
}
q.count = int32(size)
return q
} | |
c179269 | nil {
q.err = errors.New("datastore: invalid cursor")
return q
}
q.start = c.cc
return q
} | |
c179270 | nil {
q.err = errors.New("datastore: invalid cursor")
return q
}
q.end = c.cc
return q
} | |
c179271 | true)
// n += 1000 // n == 2000
// call Next with (offset, limit) = (12, 0) // 12 == newQ.offset - n
// response has (skippedResults, moreResults) = (12, false)
// n += 12 // n == 2012
// // exit the loop
// n -= 4 // n == 2008
var n int32
for {
// The QueryResult should have no actual entity data, just skipped results.
if len(res.Result) != 0 {
return 0, errors.New("datastore: internal error: Count request returned too much data")
}
n += res.GetSkippedResults()
if !res.GetMoreResults() {
break
}
if err := callNext(c, res, newQ.offset-n, q.count); err != nil {
return 0, err
}
}
n -= q.offset
if n < 0 {
// If the offset was greater than the number of matching entities,
// return 0 instead of negative.
n = 0
}
return int(n), nil
} | |
c179272 |
}
offset := q.offset - t.res.GetSkippedResults()
var count int32
if t.count > 0 && (t.limit < 0 || t.count < t.limit) {
count = t.count
} else {
count = t.limit
}
for offset > 0 && t.res.GetMoreResults() {
t.prevCC = t.res.CompiledCursor
if err := callNext(t.c, &t.res, offset, count); err != nil {
t.err = err
break
}
skip := t.res.GetSkippedResults()
if skip < 0 {
t.err = errors.New("datastore: internal error: negative number of skipped_results")
break
}
offset -= skip
}
if offset < 0 {
t.err = errors.New("datastore: internal error: query offset was overshot")
}
return t
} | |
c179273 | && !t.q.keysOnly {
err = loadEntity(dst, e)
}
return k, err
} | |
c179274 |
// the most recent compiled cursor. This is done on a best-effort basis, as it
// is racy; if a concurrent process has added or removed entities, then the
// cursor returned may be inconsistent.
q := t.q.clone()
q.start = t.prevCC
q.offset = skipped + int32(t.i)
q.limit = 0
q.keysOnly = len(q.projection) == 0
t1 := q.Run(t.c)
_, _, err := t1.next()
if err != Done {
if err == nil {
err = fmt.Errorf("datastore: internal error: zero-limit query did not have zero results")
}
return Cursor{}, err
}
return Cursor{t1.res.CompiledCursor}, nil
} | |
c179275 | unchanged protobuf value fails.
panic(fmt.Sprintf("datastore: internal error: malformed cursor: %v", err))
}
return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
} | |
c179276 | err
}
cc := &pb.CompiledCursor{}
if err := proto.Unmarshal(b, cc); err != nil {
return Cursor{}, err
}
return Cursor{cc}, nil
} | |
c179277 | err = SaveStruct(src)
}
if err != nil {
return nil, err
}
return propertiesToProto(defaultAppID, key, props)
} | |
c179278 | not match /%s/", namespace, validNamespace)
}
return internal.NamespacedContext(c, namespace), nil
} | |
c179279 | nil {
if t := cfg.Func[name]; t != "" {
return "func()" + t
}
}
return ""
} | |
c179280 | cfg.Type[e]
if etyp != nil {
if t := etyp.dot(cfg, name); t != "" {
return t
}
}
}
return ""
} | |
c179281 | (" + join(out) + ")"
}
return "func(" + join(in) + ")" + outs
} | |
c179282 | return false
}
} else {
if c != '_' && !unicode.IsLetter(c) && !unicode.IsDigit(c) {
return false
}
}
}
}
return true
} | |
c179283 | structCodecsMutex.Unlock()
return getStructCodecLocked(t)
} | |
c179284 | nil {
return err
}
return x.Load(p)
} | |
c179285 | err := newStructPLS(src)
if err != nil {
return nil, err
}
return x.Save()
} | |
c179286 | the image resized to 32 pixels, preserving the aspect ratio.
// - adding "=s32-c" is the same as "=s32" except it will be cropped.
u := *res.Url
if opts != nil && opts.Size > 0 {
u += fmt.Sprintf("=s%d", opts.Size)
if opts.Crop {
u += "-c"
}
}
return url.Parse(u)
} | |
c179287 | &pb.ImagesDeleteUrlBaseResponse{}
return internal.Call(c, "images", "DeleteUrlBase", req, res)
} | |
c179288 | to preserve existing behavior.
req.Scopes = scopes
}
res := &pb.GetOAuthUserResponse{}
err := internal.Call(c, "user", "GetOAuthUser", req, res)
if err != nil {
return nil, err
}
return &User{
Email: *res.Email,
AuthDomain: *res.AuthDomain,
Admin: res.GetIsAdmin(),
ID: *res.UserId,
ClientID: res.GetClientId(),
}, nil
} | |
c179289 | internal.Call(c, "user", "CheckOAuthSignature", req, res)
if err != nil {
return "", err
}
return *res.OauthConsumerKey, err
} | |
c179290 | u.FederatedIdentity != "" {
return u.FederatedIdentity
}
return u.Email
} | |
c179291 | return LoginURLFederated(c, dest, "")
} | |
c179292 | if err := internal.Call(c, "user", "CreateLoginURL", req, res); err != nil {
return "", err
}
return *res.LoginUrl, nil
} | |
c179293 | := internal.Call(c, "user", "CreateLogoutURL", req, res); err != nil {
return "", err
}
return *res.LogoutUrl, nil
} | |
c179294 | drop the position information.
ctx = ast.NewIdent(ctx.Name)
}
call.Args = append([]ast.Expr{ctx}, call.Args...)
} | |
c179295 | "http"
}
u := url.String()
appID, err := getAppID(wrapClient, u)
if err != nil {
return nil, fmt.Errorf("unable to contact server: %v", err)
}
return &Client{
hc: wrapClient,
url: u,
appID: appID,
}, nil
} | |
c179296 | internal.WithLogOverride(ctx, c.logf)
ctx = internal.WithAppIDOverride(ctx, c.appID)
return ctx
} | |
c179297 | c, err := NewClient(host, client)
if err != nil {
return nil, err
}
return c.NewContext(context.Background()), nil
} | |
c179298 | internal.Logf(ctx, 0, format, args...)
} | |
c179299 | return datastore.NewKey(ctx, "Guestbook", "default_guestbook", 0, nil)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.