id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c179300 | > 0 {
params.MaxBackoffSec = proto.Float64(opt.MaxBackoff.Seconds())
}
if opt.MaxDoublings > 0 || (opt.MaxDoublings == 0 && opt.ApplyZeroMaxDoublings) {
params.MaxDoublings = proto.Int32(opt.MaxDoublings)
}
return params
} | |
c179301 | path,
Payload: []byte(params.Encode()),
Header: h,
Method: "POST",
}
} | |
c179302 | {
ret.TaskETA = time.Unix(etaSecs, 0)
}
ret.TaskPreviousResponse, _ = strconv.Atoi(h.Get("X-AppEngine-TaskPreviousResponse"))
ret.TaskRetryReason = h.Get("X-AppEngine-TaskRetryReason")
if h.Get("X-AppEngine-FailFast") != "" {
ret.FailFast = true
}
return ret
} | |
c179303 |
return nil, ErrTaskAlreadyAdded
}
return nil, err
}
resultTask := *task
resultTask.Method = task.method()
if task.Name == "" {
resultTask.Name = string(res.ChosenTaskName)
}
return &resultTask, nil
} | |
c179304 | nil {
return nil, err
}
if len(res.Taskresult) != len(tasks) {
return nil, errors.New("taskqueue: server error")
}
tasksOut := make([]*Task, len(tasks))
for i, tr := range res.Taskresult {
tasksOut[i] = new(Task)
*tasksOut[i] = *tasks[i]
tasksOut[i].Method = tasksOut[i].method()
if tasksOut[i].Name == "" {
tasksOut[i].Name = string(tr.ChosenTaskName)
}
if *tr.Result != pb.TaskQueueServiceError_OK {
if alreadyAddedErrors[*tr.Result] {
me[i] = ErrTaskAlreadyAdded
} else {
me[i] = &internal.APIError{
Service: "taskqueue",
Code: int32(*tr.Result),
}
}
any = true
}
}
if any {
return tasksOut, me
}
return tasksOut, nil
} | |
c179305 | []*Task{task}, queueName)
if me, ok := err.(appengine.MultiError); ok {
return me[0]
}
return err
} | |
c179306 | requested deletion of %d tasks, got %d results", a, b)
}
me, any := make(appengine.MultiError, len(res.Result)), false
for i, ec := range res.Result {
if ec != pb.TaskQueueServiceError_OK {
me[i] = &internal.APIError{
Service: "taskqueue",
Code: int32(ec),
}
any = true
}
}
if any {
return me
}
return nil
} | |
c179307 |
return lease(c, maxTasks, queueName, leaseTime, false, nil)
} | |
c179308 | int, tag string) ([]*Task, error) {
return lease(c, maxTasks, queueName, leaseTime, true, []byte(tag))
} | |
c179309 | &pb.TaskQueuePurgeQueueResponse{}
return internal.Call(c, "taskqueue", "PurgeQueue", req, res)
} | |
c179310 | LeaseSeconds: proto.Float64(float64(leaseTime)),
}
res := &pb.TaskQueueModifyTaskLeaseResponse{}
if err := internal.Call(c, "taskqueue", "ModifyTaskLease", req, res); err != nil {
return err
}
task.ETA = time.Unix(0, *res.UpdatedEtaUsec*1e3)
return nil
} | |
c179311 | Tasks: int(*qsg.NumTasks),
}
if eta := *qsg.OldestEtaUsec; eta > -1 {
qs[i].OldestETA = time.Unix(0, eta*1e3)
}
if si := qsg.ScannerInfo; si != nil {
qs[i].Executed1Minute = int(*si.ExecutedLastMinute)
qs[i].InFlight = int(si.GetRequestsInFlight())
qs[i].EnforcedRate = si.GetEnforcedRate()
}
}
return qs, nil
} | |
c179312 | err.(interface {
IsTimeout() bool
}); ok {
return t.IsTimeout()
}
return false
} | |
c179313 |
}
// Register the function's arguments with the gob package.
// This is required because they are marshaled inside a []interface{}.
// gob.Register only expects to be called during initialization;
// that's fine because this function expects the same.
for i := 0; i < t.NumIn(); i++ {
// Only concrete types may be registered. If the argument has
// interface type, the client is resposible for registering the
// concrete types it will hold.
if t.In(i).Kind() == reflect.Interface {
continue
}
gob.Register(reflect.Zero(t.In(i)).Interface())
}
if old := funcs[f.key]; old != nil {
old.err = fmt.Errorf("multiple functions registered for %s in %s", key, file)
}
funcs[f.key] = f
return f
} | |
c179314 | type: %v is not nilable", i, dt)
}
switch at.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
av := reflect.ValueOf(args[i-1])
if av.IsNil() {
// nil value in interface; not supported by gob, so we replace it
// with a nil interface value
args[i-1] = nil
}
}
if !at.AssignableTo(dt) {
return nil, fmt.Errorf("delay: argument %d has wrong type: %v is not assignable to %v", i, at, dt)
}
}
inv := invocation{
Key: f.key,
Args: args,
}
buf := new(bytes.Buffer)
if err := gob.NewEncoder(buf).Encode(inv); err != nil {
return nil, fmt.Errorf("delay: gob encoding failed: %v", err)
}
return &taskqueue.Task{
Path: path,
Payload: buf.Bytes(),
}, nil
} | |
c179315 | c.Value(headersContextKey).(*taskqueue.RequestHeaders); ok {
return ret, nil
}
return nil, errOutsideDelayFunc
} | |
c179316 | context.Context {
return internal.WithContext(parent, req)
} | |
c179317 | {
return internal.WithCallOverride(ctx, internal.CallOverrideFunc(f))
} | |
c179318 | in, out proto.Message) error {
return internal.Call(ctx, service, method, in, out)
} | |
c179319 | req.Instance = &instance
}
res := &modpb.GetHostnameResponse{}
if err := internal.Call(c, "modules", "GetHostname", req, res); err != nil {
return "", err
}
return *res.Hostname, nil
} | |
c179320 | res)
if err != nil {
return "", time.Time{}, err
}
return res.GetAccessToken(), time.Unix(res.GetExpirationTime(), 0), nil
} | |
c179321 |
for _, pc := range res.PublicCertificateList {
cs = append(cs, Certificate{
KeyName: pc.GetKeyName(),
Data: []byte(pc.GetX509CertificatePem()),
})
}
return cs, nil
} | |
c179322 | internal.Call(c, "app_identity_service", "GetServiceAccountName", req, res)
if err != nil {
return "", err
}
return res.GetServiceAccountName(), err
} | |
c179323 | internal.Call(c, "app_identity_service", "SignForApp", req, res); err != nil {
return "", nil, err
}
return res.GetKeyName(), res.GetSignatureBytes(), nil
} | |
c179324 | "blobstore", "FetchData", req, res); err != nil {
return err
}
if len(res.Data) == 0 {
return io.EOF
}
r.buf, r.r, r.off = res.Data, 0, off
return nil
} | |
c179325 | = int(delta)
return off, nil
}
r.buf, r.r, r.off = nil, 0, off
return off, nil
} | |
c179326 | make([]*pb.Reference, len(key))
for i, k := range key {
ret[i] = keyToProto(appID, k)
}
return ret
} | |
c179327 | k,
appID: appID,
namespace: namespace,
}
if !k.valid() {
return nil, ErrInvalidKey
}
}
return
} | |
c179328 |
Id: e.Id,
Name: e.Name,
}
}
return &pb.PropertyValue_ReferenceValue{
App: ref.App,
NameSpace: ref.NameSpace,
Pathelement: pe,
}
} | |
c179329 | if me, ok := err.(appengine.MultiError); ok {
return nil, me[0]
}
return nil, err
}
return k[0], nil
} | |
c179330 | != nil {
return nil, err
}
if len(key) != len(res.Key) {
return nil, errors.New("datastore: internal error: server returned the wrong number of keys")
}
ret := make([]*Key, len(key))
for i := range ret {
var err error
ret[i], err = protoToKey(res.Key[i])
if err != nil || ret[i].Incomplete() {
return nil, errors.New("datastore: internal error: server returned an invalid key")
}
}
return ret, nil
} | |
c179331 | ok := err.(appengine.MultiError); ok {
return me[0]
}
return err
} | |
c179332 | &pb.DeleteRequest{
Key: multiKeyToProto(internal.FullyQualifiedAppID(c), key),
}
res := &pb.DeleteResponse{}
return internal.Call(c, "datastore_v3", "Delete", req, res)
} | |
c179333 | cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
if err := cmd.Run(); err != nil {
return fmt.Errorf("unable to run %q: %v", strings.Join(flag.Args(), " "), err)
}
return nil
} | |
c179334 | return nil, Done
}
if err := qr.run(); err != nil {
// Errors here may be retried, so don't store the error.
return nil, err
}
return qr.Next()
} | |
c179335 | Level: int(*line.Level),
Message: *line.LogMessage,
}
}
return appLogs
} | |
c179336 | * time.Microsecond,
MCycles: *rl.Mcycles,
Method: *rl.Method,
Resource: *rl.Resource,
HTTPVersion: *rl.HttpVersion,
Status: *rl.Status,
ResponseSize: *rl.ResponseSize,
Referrer: rl.GetReferrer(),
UserAgent: rl.GetUserAgent(),
URLMapEntry: *rl.UrlMapEntry,
Combined: *rl.Combined,
Host: rl.GetHost(),
Cost: rl.GetCost(),
TaskQueueName: rl.GetTaskQueueName(),
TaskName: rl.GetTaskName(),
WasLoadingRequest: rl.GetWasLoadingRequest(),
PendingTime: time.Duration(rl.GetPendingTime()) * time.Microsecond,
Finished: rl.GetFinished(),
AppLogs: protoToAppLogs(rl.Line),
InstanceID: string(rl.GetCloneKey()),
}
} | |
c179337 | internal.FullyQualifiedAppID(c), appengine.VersionID(c))
return &Result{
context: c,
request: req,
err: err,
}
} | |
c179338 | res.Offset
r.resultsSeen = true
for i, log := range res.Log {
r.logs[i] = protoToRecord(log)
}
return nil
} | |
c179339 | h.Get("X-AppEngine-User-Id"),
Admin: h.Get("X-AppEngine-User-Is-Admin") == "1",
FederatedIdentity: h.Get("X-AppEngine-Federated-Identity"),
FederatedProvider: h.Get("X-AppEngine-Federated-Provider"),
}
if u.Email == "" && u.FederatedIdentity == "" {
return nil
}
return u
} | |
c179340 | h.Get("X-AppEngine-User-Is-Admin") == "1"
} | |
c179341 | := err.(*datastore.ErrFieldMismatch)
return ok
} | |
c179342 |
if err := datastore.Get(c, dskey, bi); err != nil && !isErrFieldMismatch(err) {
return nil, err
}
return bi, nil
} | |
c179343 | In production this is remapped to the empty value which
// means automatic.
hdr.Set("Content-Type", "application/vnd.google.appengine.auto")
}
} | |
c179344 | req.GsBucketName = &s
}
}
res := &blobpb.CreateUploadURLResponse{}
if err := internal.Call(c, "blobstore", "CreateUploadURL", req, res); err != nil {
return nil, err
}
return url.Parse(*res.Url)
} | |
c179345 | DeleteMulti(c, []appengine.BlobKey{blobKey})
} | |
c179346 | &basepb.VoidProto{}
if err := internal.Call(c, "blobstore", "DeleteBlob", req, res); err != nil {
return err
}
return nil
} | |
c179347 | return openBlob(c, blobKey)
} | |
c179348 | Sender: r.FormValue("from"),
To: []string{r.FormValue("to")},
Body: r.FormValue("body"),
})
})
} | |
c179349 | len(req.Jid), len(res.Status))
}
me, any := make(appengine.MultiError, len(req.Jid)), false
for i, st := range res.Status {
if st != pb.XmppMessageResponse_NO_ERROR {
me[i] = errors.New(st.String())
any = true
}
}
if any {
return me
}
return nil
} | |
c179350 | &pb.XmppInviteResponse{}
return internal.Call(c, "xmpp", "SendInvite", req, res)
} | |
c179351 | {
req.Type = &p.Type
}
if p.Sender != "" {
req.FromJid = &p.Sender
}
if p.Status != "" {
req.Status = &p.Status
}
res := &pb.XmppSendPresenceResponse{}
return internal.Call(c, "xmpp", "SendPresence", req, res)
} | |
c179352 | || res.Presence == nil {
return "", ErrPresenceUnavailable
}
presence, ok := presenceMap[*res.Presence]
if ok {
return presence, nil
}
return "", fmt.Errorf("xmpp: unknown presence %v", *res.Presence)
} | |
c179353 |
presences = append(presences, presence)
errs = append(errs, err)
}
anyErr := false
for _, subres := range res.PresenceResponse {
if !subres.GetValid() {
anyErr = true
addResult("", ErrInvalidJID)
continue
}
if !*subres.IsAvailable || subres.Presence == nil {
anyErr = true
addResult("", ErrPresenceUnavailable)
continue
}
presence, ok := presenceMap[*subres.Presence]
if ok {
addResult(presence, nil)
} else {
anyErr = true
addResult("", fmt.Errorf("xmpp: unknown presence %q", *subres.Presence))
}
}
if anyErr {
return presences, errs
}
return presences, nil
} | |
c179354 | }
codec, err := loadCodec(v.Elem().Type())
if err != nil {
return nil, err
}
return structFLS{v.Elem(), codec}, nil
} | |
c179355 | error) {
f, _, err := saveStructWithMeta(src)
return f, err
} | |
c179356 | The empty namespace key uses a numeric ID (==1), but luckily
// the string ID defaults to "" for numeric IDs anyway.
return keyNames(keys), nil
} | |
c179357 |
if err != nil {
return nil, err
}
return keyNames(keys), nil
} | |
c179358 | i < attempts; i++ {
if t, err = internal.RunTransactionOnce(c, f, xg, readOnly, t); err != internal.ErrConcurrentTransaction {
return err
}
}
return ErrConcurrentTransaction
} | |
c179359 | importSpec(f, path) != nil
} | |
c179360 | if importPath(s) == path {
return s
}
}
return nil
} | |
c179361 | {
impspec := spec.(*ast.ImportSpec)
if importPath(impspec) == path {
return true
}
}
return false
} | |
c179362 | && isTopName(sel.X, pkg) && sel.Sel.String() == name
} | |
c179363 | return ok && id.Name == name && id.Obj == nil
} | |
c179364 | n.(*ast.Ident)
return ok && id.String() == name
} | |
c179365 | return ok && isPkgDot(call.Fun, pkg, name)
} | |
c179366 | all have Obj == nil.
return ok && id.Obj == x.Obj && id.Name == x.Name
} | |
c179367 | lit.Kind == token.STRING && len(lit.Value) == 2
} | |
c179368 |
if n, ok := n.(ast.Node); ok && refersTo(n, x) {
count++
}
}
for _, n := range scope {
walk(n, ff)
}
return count
} | |
c179369 | n.Lhs {
if refersTo(l, x) {
assigned = true
return
}
}
}
}
for _, n := range scope {
if assigned {
break
}
walk(n, ff)
}
return assigned
} | |
c179370 | },
Sel: &ast.Ident{
NamePos: pos,
Name: name,
},
}
} | |
c179371 | fixed = true
}
}
}
}
}
}
// Rename top-level old to new, both unresolved names
// (probably defined in another file) and names that resolve
// to a declaration we renamed.
walk(f, func(n interface{}) {
id, ok := n.(*ast.Ident)
if ok && isTopName(id, old) {
id.Name = new
fixed = true
}
if ok && id.Obj != nil && id.Name == old && id.Obj.Name == new {
id.Name = id.Obj.Name
fixed = true
}
})
return fixed
} | |
c179372 | i < len(x) && i < len(y) && x[i] == y[i] {
i++
}
return i
} | |
c179373 | > 0 {
// We deleted an entry but now there will be
// a blank line-sized hole where the import was.
// Close the hole by making the previous
// import appear to "end" where this one did.
gen.Specs[j-1].(*ast.ImportSpec).EndPos = impspec.End()
}
break
}
}
// Delete it from f.Imports.
for i, imp := range f.Imports {
if imp == oldImport {
copy(f.Imports[i:], f.Imports[i+1:])
f.Imports = f.Imports[:len(f.Imports)-1]
break
}
}
return
} | |
c179374 | to compute
// it using the length of imp.Path.Value.
imp.EndPos = imp.End()
imp.Path.Value = strconv.Quote(newPath)
}
}
return
} | |
c179375 | i > 0 {
majVersion = majVersion[:i]
}
defaultTicket = fmt.Sprintf("%s/%s.%s.%s", escAppID, ModuleName(nil), majVersion, InstanceID())
})
return defaultTicket
} | |
c179376 | // Nothing to flush.
return false
}
rescueLogs := false
defer func() {
if rescueLogs {
c.pendingLogs.Lock()
c.pendingLogs.lines = append(lines, c.pendingLogs.lines...)
c.pendingLogs.Unlock()
}
}()
buf, err := proto.Marshal(&logpb.UserAppLogGroup{
LogLine: lines,
})
if err != nil {
log.Printf("internal.flushLog: marshaling UserAppLogGroup: %v", err)
rescueLogs = true
return false
}
req := &logpb.FlushRequest{
Logs: buf,
}
res := &basepb.VoidProto{}
c.pendingLogs.Lock()
c.pendingLogs.flushes++
c.pendingLogs.Unlock()
if err := Call(toContext(c), "logservice", "Flush", req, res); err != nil {
log.Printf("internal.flushLog: Flush RPC: %v", err)
rescueLogs = true
return false
}
return true
} | |
c179377 | func() {}
}
return context.WithDeadline(parent, deadline)
} | |
c179378 | internal.Call(cn.ctx, "remote_socket", "GetSocketName", req, res)
} | |
c179379 | := transactionSetters[v.Type()]; ok {
f.Call([]reflect.Value{v, reflect.ValueOf(t)})
}
} | |
c179380 |
return nil, err
}
gopath := filepath.SplitList(ctxt.GOPATH)
im, err := imports(ctxt, *rootDir, gopath)
return &app{
hasMain: hasMain,
appFiles: appFiles,
imports: im,
}, err
} | |
c179381 | GOROOT: build.Default.GOROOT,
GOPATH: build.Default.GOPATH,
Compiler: build.Default.Compiler,
BuildTags: append(build.Default.BuildTags, tags...),
}
} | |
c179382 | if err := tw.WriteHeader(hdr); err != nil {
return fmt.Errorf("unable to write header for %v: %v", f, err)
}
if _, err := tw.Write([]byte(newMain)); err != nil {
return fmt.Errorf("unable to write %v to tar file: %v", f, err)
}
return nil
} | |
c179383 | nil
}
}
return "", fmt.Errorf("unable to find package %v in gopath %v", dir, gopath)
} | |
c179384 | nil {
return fmt.Errorf("unable to copy dir %v to %v: %v", s, d, err)
}
continue
}
if err := copyFile(tw, d, s); err != nil {
return fmt.Errorf("unable to copy dir %v to %v: %v", s, d, err)
}
}
return nil
} | |
c179385 | err := tw.WriteHeader(hdr); err != nil {
return fmt.Errorf("unable to write header for %v: %v", dst, err)
}
_, err = io.Copy(tw, s)
if err != nil {
return fmt.Errorf("unable to copy %v to %v: %v", src, dst, err)
}
return nil
} | |
c179386 | := filepath.Join(*rootDir, f)
appFiles = append(appFiles, n)
if hasMain, err = readFile(n); err != nil {
return false, nil, fmt.Errorf("error parsing %q: %v", n, err)
}
}
return hasMain, appFiles, nil
} | |
c179387 | == "main" && f.Recv == nil && ft.Params.NumFields() == 0 && ft.Results.NumFields() == 0
} | |
c179388 | funcDecl, ok := decl.(*ast.FuncDecl)
if !ok {
continue
}
if !isMain(funcDecl) {
continue
}
hasMain = true
break
}
return
} | |
c179389 | if val.Kind() == reflect.Ptr {
if val.IsNil() {
val.Set(reflect.New(val.Type().Elem()))
}
val = val.Elem()
}
}
return val.Field(index[len(index)-1])
} | |
c179390 | {
return e.Load(ent.Properties)
}
return LoadStruct(dst, ent.Properties)
} | |
c179391 | c < 0x21 || 0x7f <= c {
return false
}
}
return true
} | |
c179392 |
return &Index{
spec: pb.IndexSpec{
Name: &name,
},
}, nil
} | |
c179393 | {
ids, err := x.PutMulti(c, []string{id}, []interface{}{src})
if err != nil {
return "", err
}
return ids[0], nil
} | |
c179394 | == nil || res.Status.GetCode() != pb.SearchServiceError_OK {
return fmt.Errorf("search: %s: %s", res.Status.GetCode(), res.Status.GetErrorDetail())
}
if len(res.Document) != 1 || res.Document[0].GetId() != id {
return ErrNoSuchDocument
}
return loadDoc(dst, res.Document[0], nil)
} | |
c179395 |
return x.DeleteMulti(c, []string{id})
} | |
c179396 | len(ids))
}
multiErr, hasErr := make(appengine.MultiError, len(ids)), false
for i, s := range res.Status {
if s.GetCode() != pb.SearchServiceError_OK {
multiErr[i] = fmt.Errorf("search: %s: %s", s.GetCode(), s.GetErrorDetail())
hasErr = true
}
}
if hasErr {
return multiErr
}
return nil
} | |
c179397 | = opts.IDsOnly
t.sort = opts.Sort
t.exprs = opts.Expressions
t.refinements = opts.Refinements
t.facetOpts = opts.Facets
t.searchOffset = opts.Offset
t.countAccuracy = opts.CountAccuracy
}
return t
} | |
c179398 | == 0 && t.more != nil {
t.err = t.more(t)
}
} | |
c179399 | {
return "", errors.New("search: internal error: no document returned")
}
if !t.idsOnly && dst != nil {
if err := loadDoc(dst, doc, exprs); err != nil {
return "", err
}
}
return doc.GetId(), nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.