id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c177400 | nil {
downloadTime = err.Error()
}
downloadTime = dl.String()
fmt.Fprintf(w, "Download Time\t%s\n", downloadTime)
var procTime string
proc, err := types.DurationFromProto(datumInfo.Stats.ProcessTime)
if err != nil {
procTime = err.Error()
}
procTime = proc.String()
fmt.Fprintf(w, "Process Time\t%s\n", procTime)
var uploadTime string
ul, err := types.DurationFromProto(datumInfo.Stats.UploadTime)
if err != nil {
uploadTime = err.Error()
}
uploadTime = ul.String()
fmt.Fprintf(w, "Upload Time\t%s\n", uploadTime)
fmt.Fprintf(w, "PFS State:\n")
tw := ansiterm.NewTabWriter(w, 10, 1, 3, ' ', 0)
PrintFileHeader(tw)
PrintFile(tw, datumInfo.PfsState)
tw.Flush()
fmt.Fprintf(w, "Inputs:\n")
tw = ansiterm.NewTabWriter(w, 10, 1, 3, ' ', 0)
PrintFileHeader(tw)
for _, d := range datumInfo.Data {
PrintFile(tw, d.File)
}
tw.Flush()
} | |
c177401 | " %s\t%s\t%s\t\n", file.Commit.Repo.Name, file.Commit.ID, file.Path)
} | |
c177402 | range input.Union {
subInput = append(subInput, ShorthandInput(input))
}
return "(" + strings.Join(subInput, " ∪ ") + ")"
case input.Cron != nil:
return fmt.Sprintf("%s:%s", input.Cron.Name, input.Cron.Spec)
}
return ""
} | |
c177403 | renewInterval := v.getLeaseDuration()
if renewInterval.Seconds() < oneDayInSeconds {
renewInterval = oneDayInSeconds * time.Second
}
// Wait until 'renewInterval' has elapsed, then renew the lease
time.Sleep(renewInterval)
backoff.RetryNotify(func() error {
// every two days, renew the lease for this node's AWS credentials
vaultSecret, err := v.vaultClient.Sys().Renew(v.leaseID, twoDaysInSeconds)
if err != nil {
return err
}
v.updateLease(vaultSecret)
return nil
}, backoff.NewExponentialBackOff(), func(err error, _ time.Duration) error {
log.Errorf("could not renew vault lease: %v", err)
return nil
})
}
}()
// Per https://www.vaultproject.io/docs/secrets/aws/index.html#usage, wait
// until token is usable
time.Sleep(10 * time.Second)
return result, nil
} | |
c177404 | return time.Now().After(v.leaseLastRenew.Add(v.leaseDuration))
} | |
c177405 | {
return &pfs.Branch{
Repo: NewRepo(repoName),
Name: branchName,
}
} | |
c177406 | {
return &pfs.Commit{
Repo: NewRepo(repoName),
ID: commitID,
}
} | |
c177407 | {
return &pfs.CommitProvenance{
Commit: NewCommit(repoName, commitID),
Branch: NewBranch(repoName, branchName),
}
} | |
c177408 | {
return &pfs.File{
Commit: NewCommit(repoName, commitID),
Path: path,
}
} | |
c177409 | Repo: NewRepo(repoName),
},
)
return grpcutil.ScrubGRPC(err)
} | |
c177410 | c.Ctx(),
&pfs.InspectRepoRequest{
Repo: NewRepo(repoName),
},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return resp, nil
} | |
c177411 | := c.PfsAPIClient.ListRepo(
c.Ctx(),
request,
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return repoInfos.RepoInfo, nil
} | |
c177412 | Repo: NewRepo(repoName),
Force: force,
},
)
return grpcutil.ScrubGRPC(err)
} | |
c177413 | Tree: &pfs.Object{Hash: treeObject},
},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return commit, nil
} | |
c177414 | &pfs.StartCommitRequest{
Parent: &pfs.Commit{
Repo: &pfs.Repo{
Name: repoName,
},
ID: parentCommit,
},
Branch: branch,
},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return commit, nil
} | |
c177415 | Commit: NewCommit(repoName, commitID),
},
)
return grpcutil.ScrubGRPC(err)
} | |
c177416 | return c.inspectCommit(repoName, commitID, pfs.CommitState_STARTED)
} | |
c177417 | c.inspectCommit(repoName, commitID, pfs.CommitState_FINISHED)
} | |
c177418 | *pfs.CommitInfo) error {
result = append(result, ci)
return nil
}); err != nil {
return nil, err
}
return result, nil
} | |
c177419 | := stream.Recv()
if err == io.EOF {
break
} else if err != nil {
return grpcutil.ScrubGRPC(err)
}
if err := f(ci); err != nil {
if err == errutil.ErrBreak {
return nil
}
return err
}
}
return nil
} | |
c177420 | return c.ListCommit(repoName, "", "", 0)
} | |
c177421 | Branch: NewBranch(repoName, branch),
Head: head,
Provenance: provenance,
},
)
return grpcutil.ScrubGRPC(err)
} | |
c177422 | Branch: NewBranch(repoName, branch),
},
)
return branchInfo, grpcutil.ScrubGRPC(err)
} | |
c177423 | err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return branchInfos.BranchInfo, nil
} | |
c177424 |
return c.CreateBranch(repoName, branch, commit, nil)
} | |
c177425 | Branch: NewBranch(repoName, branch),
Force: force,
},
)
return grpcutil.ScrubGRPC(err)
} | |
c177426 | Commit: NewCommit(repoName, commitID),
},
)
return grpcutil.ScrubGRPC(err)
} | |
c177427 |
},
)
if err != nil {
cancel()
return nil, grpcutil.ScrubGRPC(err)
}
return &commitInfoIterator{stream, cancel}, nil
} | |
c177428 |
if err != nil {
if err == io.EOF {
return nil
}
return grpcutil.ScrubGRPC(err)
}
if err := f(ci); err != nil {
return err
}
}
} | |
c177429 | {
result = append(result, ci)
return nil
}); err != nil {
return nil, err
}
return result, nil
} | |
c177430 | Repo: NewRepo(repo),
Branch: branch,
State: state,
}
if from != "" {
req.From = NewCommit(repo, from)
}
stream, err := c.PfsAPIClient.SubscribeCommit(ctx, req)
if err != nil {
cancel()
return nil, grpcutil.ScrubGRPC(err)
}
return &commitInfoIterator{stream, cancel}, nil
} | |
c177431 | c.PfsAPIClient.SubscribeCommit(c.Ctx(), req)
if err != nil {
return grpcutil.ScrubGRPC(err)
}
for {
ci, err := stream.Recv()
if err != nil {
return grpcutil.ScrubGRPC(err)
}
if err := f(ci); err != nil {
return grpcutil.ScrubGRPC(err)
}
}
} | |
c177432 | != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return w, nil
} | |
c177433 | w.object
}
}()
buf := grpcutil.GetBuffer()
defer grpcutil.PutBuffer(buf)
written, err := io.CopyBuffer(w, r, buf)
if err != nil {
return nil, 0, grpcutil.ScrubGRPC(err)
}
// return value set by deferred function
return nil, written, nil
} | |
c177434 | }
}()
buf := grpcutil.GetBuffer()
defer grpcutil.PutBuffer(buf)
written, err := io.CopyBuffer(w, r, buf)
if err != nil {
return nil, 0, grpcutil.ScrubGRPC(err)
}
// return value set by deferred function
return nil, written, nil
} | |
c177435 | := grpcutil.WriteFromStreamingBytesClient(getObjectClient, writer); err != nil {
return grpcutil.ScrubGRPC(err)
}
return nil
} | |
c177436 | return nil, grpcutil.ScrubGRPC(err)
}
return grpcutil.NewStreamingBytesReader(getObjectClient, cancel), nil
} | |
c177437 | totalSize,
},
)
if err != nil {
return grpcutil.ScrubGRPC(err)
}
if err := grpcutil.WriteFromStreamingBytesClient(getObjectsClient, writer); err != nil {
return grpcutil.ScrubGRPC(err)
}
return nil
} | |
c177438 | Object: &pfs.Object{Hash: hash},
Tags: _tags,
},
); err != nil {
return grpcutil.ScrubGRPC(err)
}
return nil
} | |
c177439 | if err != nil {
if err == io.EOF {
return nil
}
return grpcutil.ScrubGRPC(err)
}
if err := f(object); err != nil {
return err
}
}
} | |
c177440 |
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return value, nil
} | |
c177441 | := grpcutil.WriteFromStreamingBytesClient(getTagClient, writer); err != nil {
return grpcutil.ScrubGRPC(err)
}
return nil
} | |
c177442 | return nil, grpcutil.ScrubGRPC(err)
}
return grpcutil.NewStreamingBytesReader(getTagClient, cancel), nil
} | |
c177443 | {
return grpcutil.ScrubGRPC(err)
}
for {
listTagResponse, err := listTagClient.Recv()
if err != nil {
if err == io.EOF {
return nil
}
return grpcutil.ScrubGRPC(err)
}
if err := f(listTagResponse); err != nil {
return err
}
}
} | |
c177444 | c.Ctx(),
&types.Empty{},
)
return err
} | |
c177445 | nil, grpcutil.ScrubGRPC(err)
}
return &putFileClient{c: pfc}, nil
} | |
c177446 | }
defer func() {
if err := writer.Close(); err != nil && retErr == nil {
retErr = err
}
}()
written, err := io.Copy(writer, reader)
return int(written), grpcutil.ScrubGRPC(err)
} | |
c177447 | return grpcutil.ScrubGRPC(err)
} | |
c177448 | Dst: NewFile(dstRepo, dstCommit, dstPath),
Overwrite: overwrite,
}); err != nil {
return grpcutil.ScrubGRPC(err)
}
return nil
} | |
c177449 | return grpcutil.ScrubGRPC(err)
}
if err := grpcutil.WriteFromStreamingBytesClient(apiGetFileClient, writer); err != nil {
return grpcutil.ScrubGRPC(err)
}
return nil
} | |
c177450 | := c.getFile(repoName, commitID, path, offset, size)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return grpcutil.NewStreamingBytesReader(apiGetFileClient, nil), nil
} | |
c177451 | {
return nil, err
}
return &getFileReadSeeker{
Reader: reader,
file: NewFile(repoName, commitID, path),
offset: 0,
size: int64(fileInfo.SizeBytes),
c: c,
}, nil
} | |
c177452 | {
return c.inspectFile(repoName, commitID, path)
} | |
c177453 | if err := c.ListFileF(repoName, commitID, path, 0, func(fi *pfs.FileInfo) error {
result = append(result, fi)
return nil
}); err != nil {
return nil, err
}
return result, nil
} | |
c177454 | *pfs.FileInfo) error {
result = append(result, fi)
return nil
}); err != nil {
return nil, err
}
return result, nil
} | |
c177455 | err == io.EOF {
return nil
} else if err != nil {
return grpcutil.ScrubGRPC(err)
}
if err := f(fi); err != nil {
if err == errutil.ErrBreak {
return nil
}
return err
}
}
} | |
c177456 | else if err != nil {
return grpcutil.ScrubGRPC(err)
}
if err := f(fi); err != nil {
if err == errutil.ErrBreak {
return nil
}
return err
}
}
} | |
c177457 | := c.PfsAPIClient.DeleteFile(
c.Ctx(),
&pfs.DeleteFileRequest{
File: NewFile(repoName, commitID, path),
},
)
return err
} | |
c177458 | append(w.buf, p[:i]...)
p = p[i:]
w.writeChan <- w.buf
w.buf = grpcutil.GetBuffer()[:0]
}
w.buf = append(w.buf, p...)
}
return len(p), nil
} | |
c177459 | <-w.errChan
if err != nil {
return grpcutil.ScrubGRPC(err)
}
w.object, err = w.client.CloseAndRecv()
return grpcutil.ScrubGRPC(err)
} | |
c177460 | version.Major, version.Minor, version.Micro)
} | |
c177461 | cmd := range parent.Commands() {
recursiveBlockQuoteExamples(cmd)
}
} | |
c177462 | logical.ErrorResponse(fmt.Sprintf("missing required field '%s'", field))
} | |
c177463 | }
}
if len(unknownFields) > 0 {
return fmt.Errorf("unknown fields: %q", unknownFields)
}
return nil
} | |
c177464 | s.Put(ctx, entry); err != nil {
return fmt.Errorf("%v: failed to write configuration to storage", err)
}
return nil
} | |
c177465 | configuration in storage")
}
var result config
if err := entry.DecodeJSON(&result); err != nil {
return nil, fmt.Errorf("%v: failed to decode configuration", err)
}
return &result, nil
} | |
c177466 | if certPathStatErr == nil && keyPathStatErr == nil {
// Read TLS cert and key
transportCreds, err := credentials.NewServerTLSFromFile(certPath, keyPath)
if err != nil {
return fmt.Errorf("couldn't build transport creds: %v", err)
}
opts = append(opts, grpc.Creds(transportCreds))
}
}
grpcServer := grpc.NewServer(opts...)
if err := server.RegisterFunc(grpcServer); err != nil {
return err
}
listener, err := net.Listen("tcp", fmt.Sprintf(":%d", server.Port))
if err != nil {
return err
}
if server.Cancel != nil {
go func() {
<-server.Cancel
if err := listener.Close(); err != nil {
fmt.Printf("listener.Close(): %v\n", err)
}
}()
}
if err := grpcServer.Serve(listener); err != nil {
return err
}
}
return nil
} | |
c177467 | errCh: make(chan error, 1),
pipes: make(map[string]bool),
}
} | |
c177468 | return client.GetObjects(hashes, 0, 0, uint64(node.SubtreeSize), w)
})
}
limiter.Acquire()
eg.Go(func() (retErr error) {
defer limiter.Release()
return p.makeFile(path, func(w io.Writer) error {
return client.GetObjects(hashes, 0, 0, uint64(node.SubtreeSize), w)
})
})
}
return nil
}); err != nil {
return err
}
return eg.Wait()
} | |
c177469 | err
}
if overwrite {
if err := client.DeleteFile(commit.Repo.Name, commit.ID, relPath); err != nil {
return err
}
}
_, err = client.PutFile(commit.Repo.Name, commit.ID, relPath, f)
return err
})
return nil
}); err != nil {
return err
}
return g.Wait()
} | |
c177470 | err != nil {
return err
}
defer func() {
if err := w.Close(); err != nil && retErr == nil {
retErr = err
}
}()
return pachClient.GetFile(commit.Repo.Name, commit.ID, fileInfo.File.Path, 0, 0, w)
})
return nil
}); err != nil {
return err
}
return eg.Wait()
} | |
c177471 | object = range fileInfo.Objects {
hash := pfs.NewHash()
if _, err := io.CopyN(hash, osFile, pfs.ChunkSize); err != nil {
if err == io.EOF {
break
}
return err
}
if object.Hash != pfs.EncodeHash(hash.Sum(nil)) {
break
}
}
}
if _, err := osFile.Seek(int64(i)*pfs.ChunkSize, 0); err != nil {
return err
}
_, err = pfc.PutFileOverwrite(pfsFile.Commit.Repo.Name, pfsFile.Commit.ID, pfsFile.Path, osFile, int64(i))
return err
} | |
c177472 | grpcutil.ScrubGRPC(err)
}
return grpcutil.ScrubGRPC(grpcutil.WriteFromStreamingBytesClient(goroClient, w))
} | |
c177473 | err != nil {
return grpcutil.ScrubGRPC(err)
}
return grpcutil.ScrubGRPC(grpcutil.WriteFromStreamingBytesClient(profileClient, w))
} | |
c177474 | grpcutil.ScrubGRPC(err)
}
return grpcutil.ScrubGRPC(grpcutil.WriteFromStreamingBytesClient(binaryClient, w))
} | |
c177475 | {
// metrics may be redundantly registered; ignore these errors
if _, ok := err.(prometheus.AlreadyRegisteredError); !ok {
logrus.Infof("error registering prometheus metric: %v", err)
}
}
} | |
c177476 | for c.n < n {
c.cond.Wait()
}
} | |
c177477 | return err
}
}
for _, job := range worker.startedJobs {
jobInfo, err := client.InspectJob(job.ID, true)
if err != nil {
return err
}
if jobInfo.State != pps.JobState_JOB_SUCCESS {
return fmt.Errorf("job %s failed", job.ID)
}
}
return nil
} | |
c177478 | finish a commit the first time it's
// called, and therefore must have an open commit to finish.
commit, err := c.StartCommit(repoName, "")
if err != nil {
return err
}
w.started = append(w.started, commit)
return nil
} | |
c177479 | }
// remove commit[i] from 'started' and add it to 'finished'
w.started = append(w.started[:i], w.started[i+1:]...)
w.finished = append(w.finished, commit)
} else {
// Start a new commmit (parented off of a commit that we've finished)
commit := w.finished[w.rand.Intn(len(w.finished))]
commit, err := c.StartCommitParent(commit.Repo.Name, "", commit.ID)
if err != nil {
return err
}
w.started = append(w.started, commit)
}
return nil
} | |
c177480 | b[i] = letters[r.Intn(len(letters))]
}
return string(b)
} | |
c177481 | io.Reader {
return &reader{
rand: rand,
bytes: bytes,
}
} | |
c177482 | path)
for k, v := c.K(), c.V(); k != nil; k, v = c.Next() {
if err := f(k, v, c.c); err != nil {
if err == errutil.ErrBreak {
return nil
}
return err
}
}
return nil
} | |
c177483 | return 0
}
return rootNode.SubtreeSize
} | |
c177484 | err
}
newTx = tx
oldTx = tx
defer rollback(tx)
} else {
var err error
newTx, err = h.Begin(false)
if err != nil {
return err
}
defer rollback(newTx)
oldTx, err = old.Begin(false)
if err != nil {
return err
}
defer rollback(oldTx)
}
return diff(newTx, oldTx, newPath, oldPath, recursiveDepth, f)
} | |
c177485 | _, err := w.WriteBytes(k); err != nil {
return err
}
_, err := w.WriteBytes(v)
return err
}); err != nil {
return err
}
if _, err := w.WriteBytes(SentinelByte); err != nil {
return err
}
}
return nil
})
} | |
c177486 | b(hdr.Bucket)
select {
case kvs <- &keyValue{nil, bucket}:
case <-copyCtx.Done():
return nil
}
for {
_k, err := r.ReadBytes()
if err != nil {
return err
}
if bytes.Equal(_k, SentinelByte) {
break
}
// we need to make copies of k and v because the memory will be reused
k := make([]byte, len(_k))
copy(k, _k)
_v, err := r.ReadBytes()
if err != nil {
return err
}
v := make([]byte, len(_v))
copy(v, _v)
select {
case kvs <- &keyValue{k, v}:
case <-copyCtx.Done():
return nil
}
}
}
return nil
})
return eg.Wait()
} | |
c177487 |
var err error
result, err = DeserializeDBHashTree(pathlib.Dir(h.Path()), r)
return err
})
if err := eg.Wait(); err != nil {
return nil, err
}
return result, nil
} | |
c177488 |
return err
}
return os.Remove(path)
} | |
c177489 | *pfs.OverwriteIndex, sizeDelta int64) error {
return h.putFile(path, objects, overwriteIndex, sizeDelta, false)
} | |
c177490 | calculation in canonicalize() work
SubtreeSize: headerSize + footerSize,
}
}
// only write node to db if the node is new, or the header or footer
// changed
headerSame := (node.DirNode.Shared.Header == nil && header == nil) ||
(node.DirNode.Shared.Header != nil && node.DirNode.Shared.Header.Hash == header.Hash)
footerSame := (node.DirNode.Shared.Footer == nil && footer == nil) ||
(node.DirNode.Shared.Footer != nil && node.DirNode.Shared.Footer.Hash == footer.Hash)
if newNode || !headerSame || !footerSame {
node.DirNode.Shared = &Shared{
Header: header,
Footer: footer,
HeaderSize: headerSize,
FooterSize: footerSize,
}
return put(tx, path, node)
}
return nil
})
} | |
c177491 | {
return h.putFile(path, objects, nil, size, true)
} | |
c177492 | for k, _ := c.Seek(prefix); bytes.HasPrefix(k, prefix); k, _ = c.Next() {
if err := c.Delete(); err != nil {
return err
}
}
return fs(tx).Delete(b(path))
} | |
c177493 | pbutil.NewReader(r),
filter: filter,
}
} | |
c177494 | nil, err
}
}
}
k := make([]byte, len(_k))
copy(k, _k)
_v, err := r.pbr.ReadBytes()
if err != nil {
return nil, err
}
v := make([]byte, len(_v))
copy(v, _v)
return &MergeNode{
k: k,
v: v,
}, nil
} | |
c177495 |
pbw: pbutil.NewWriter(w),
}
} | |
c177496 |
if w.offset > uint64(len(w.idxs)+1)*IndexSize {
w.idxs = append(w.idxs, &Index{
K: n.k,
Offset: w.offset,
})
}
b, err := w.pbw.WriteBytes(n.k)
if err != nil {
return err
}
w.offset += uint64(b)
b, err = w.pbw.WriteBytes(n.v)
if err != nil {
return err
}
w.offset += uint64(b)
return nil
} | |
c177497 | }
return err
}
if err := w.Write(n); err != nil {
return err
}
}
} | |
c177498 | if _, err := pbw.Write(idx); err != nil {
return nil, err
}
}
return buf.Bytes(), nil
} | |
c177499 | // Handles the case where a prefix fits within one range
upper = idx.Offset
}
return true
}
up := func(cmp int) bool {
if cmp < 0 {
upper = idx.Offset
return true
}
return false
}
// Find lower
iter(low)
// Find upper
if upper <= 0 {
iter(up)
}
// Handles the case when at the end of the indexes
if upper <= 0 {
return lower, 0, nil
}
// Return offset and size
return lower, upper - lower, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.