_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q177400 | PrintDetailedDatumInfo | test | func PrintDetailedDatumInfo(w io.Writer, datumInfo *ppsclient.DatumInfo) {
fmt.Fprintf(w, "ID\t%s\n", datumInfo.Datum.ID)
fmt.Fprintf(w, "Job ID\t%s\n", datumInfo.Datum.Job.ID)
fmt.Fprintf(w, "State\t%s\n", datumInfo.State)
fmt.Fprintf(w, "Data Downloaded\t%s\n", pretty.Size(datumInfo.Stats.DownloadBytes))
fmt.Fpr... | go | {
"resource": ""
} |
q177401 | PrintFile | test | func PrintFile(w io.Writer, file *pfsclient.File) {
fmt.Fprintf(w, " %s\t%s\t%s\t\n", file.Commit.Repo.Name, file.Commit.ID, file.Path)
} | go | {
"resource": ""
} |
q177402 | ShorthandInput | test | func ShorthandInput(input *ppsclient.Input) string {
switch {
case input == nil:
return "none"
case input.Pfs != nil:
return fmt.Sprintf("%s:%s", input.Pfs.Repo, input.Pfs.Glob)
case input.Cross != nil:
var subInput []string
for _, input := range input.Cross {
subInput = append(subInput, ShorthandInput(i... | go | {
"resource": ""
} |
q177403 | Retrieve | test | func (v *vaultCredentialsProvider) Retrieve() (credentials.Value, error) {
var emptyCreds, result credentials.Value // result
// retrieve AWS creds from vault
vaultSecret, err := v.vaultClient.Logical().Read(path.Join("aws", "creds", v.vaultRole))
if err != nil {
return emptyCreds, fmt.Errorf("could not retrieve... | go | {
"resource": ""
} |
q177404 | IsExpired | test | func (v *vaultCredentialsProvider) IsExpired() bool {
v.leaseMu.Lock()
defer v.leaseMu.Unlock()
return time.Now().After(v.leaseLastRenew.Add(v.leaseDuration))
} | go | {
"resource": ""
} |
q177405 | NewBranch | test | func NewBranch(repoName string, branchName string) *pfs.Branch {
return &pfs.Branch{
Repo: NewRepo(repoName),
Name: branchName,
}
} | go | {
"resource": ""
} |
q177406 | NewCommit | test | func NewCommit(repoName string, commitID string) *pfs.Commit {
return &pfs.Commit{
Repo: NewRepo(repoName),
ID: commitID,
}
} | go | {
"resource": ""
} |
q177407 | NewCommitProvenance | test | func NewCommitProvenance(repoName string, branchName string, commitID string) *pfs.CommitProvenance {
return &pfs.CommitProvenance{
Commit: NewCommit(repoName, commitID),
Branch: NewBranch(repoName, branchName),
}
} | go | {
"resource": ""
} |
q177408 | NewFile | test | func NewFile(repoName string, commitID string, path string) *pfs.File {
return &pfs.File{
Commit: NewCommit(repoName, commitID),
Path: path,
}
} | go | {
"resource": ""
} |
q177409 | CreateRepo | test | func (c APIClient) CreateRepo(repoName string) error {
_, err := c.PfsAPIClient.CreateRepo(
c.Ctx(),
&pfs.CreateRepoRequest{
Repo: NewRepo(repoName),
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177410 | InspectRepo | test | func (c APIClient) InspectRepo(repoName string) (*pfs.RepoInfo, error) {
resp, err := c.PfsAPIClient.InspectRepo(
c.Ctx(),
&pfs.InspectRepoRequest{
Repo: NewRepo(repoName),
},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return resp, nil
} | go | {
"resource": ""
} |
q177411 | ListRepo | test | func (c APIClient) ListRepo() ([]*pfs.RepoInfo, error) {
request := &pfs.ListRepoRequest{}
repoInfos, err := c.PfsAPIClient.ListRepo(
c.Ctx(),
request,
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return repoInfos.RepoInfo, nil
} | go | {
"resource": ""
} |
q177412 | DeleteRepo | test | func (c APIClient) DeleteRepo(repoName string, force bool) error {
_, err := c.PfsAPIClient.DeleteRepo(
c.Ctx(),
&pfs.DeleteRepoRequest{
Repo: NewRepo(repoName),
Force: force,
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177413 | BuildCommit | test | func (c APIClient) BuildCommit(repoName string, branch string, parent string, treeObject string) (*pfs.Commit, error) {
commit, err := c.PfsAPIClient.BuildCommit(
c.Ctx(),
&pfs.BuildCommitRequest{
Parent: NewCommit(repoName, parent),
Branch: branch,
Tree: &pfs.Object{Hash: treeObject},
},
)
if err !... | go | {
"resource": ""
} |
q177414 | StartCommitParent | test | func (c APIClient) StartCommitParent(repoName string, branch string, parentCommit string) (*pfs.Commit, error) {
commit, err := c.PfsAPIClient.StartCommit(
c.Ctx(),
&pfs.StartCommitRequest{
Parent: &pfs.Commit{
Repo: &pfs.Repo{
Name: repoName,
},
ID: parentCommit,
},
Branch: branch,
},
... | go | {
"resource": ""
} |
q177415 | FinishCommit | test | func (c APIClient) FinishCommit(repoName string, commitID string) error {
_, err := c.PfsAPIClient.FinishCommit(
c.Ctx(),
&pfs.FinishCommitRequest{
Commit: NewCommit(repoName, commitID),
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177416 | InspectCommit | test | func (c APIClient) InspectCommit(repoName string, commitID string) (*pfs.CommitInfo, error) {
return c.inspectCommit(repoName, commitID, pfs.CommitState_STARTED)
} | go | {
"resource": ""
} |
q177417 | BlockCommit | test | func (c APIClient) BlockCommit(repoName string, commitID string) (*pfs.CommitInfo, error) {
return c.inspectCommit(repoName, commitID, pfs.CommitState_FINISHED)
} | go | {
"resource": ""
} |
q177418 | ListCommit | test | func (c APIClient) ListCommit(repoName string, to string, from string, number uint64) ([]*pfs.CommitInfo, error) {
var result []*pfs.CommitInfo
if err := c.ListCommitF(repoName, to, from, number, func(ci *pfs.CommitInfo) error {
result = append(result, ci)
return nil
}); err != nil {
return nil, err
}
return... | go | {
"resource": ""
} |
q177419 | ListCommitF | test | func (c APIClient) ListCommitF(repoName string, to string, from string, number uint64, f func(*pfs.CommitInfo) error) error {
req := &pfs.ListCommitRequest{
Repo: NewRepo(repoName),
Number: number,
}
if from != "" {
req.From = NewCommit(repoName, from)
}
if to != "" {
req.To = NewCommit(repoName, to)
}
... | go | {
"resource": ""
} |
q177420 | ListCommitByRepo | test | func (c APIClient) ListCommitByRepo(repoName string) ([]*pfs.CommitInfo, error) {
return c.ListCommit(repoName, "", "", 0)
} | go | {
"resource": ""
} |
q177421 | CreateBranch | test | func (c APIClient) CreateBranch(repoName string, branch string, commit string, provenance []*pfs.Branch) error {
var head *pfs.Commit
if commit != "" {
head = NewCommit(repoName, commit)
}
_, err := c.PfsAPIClient.CreateBranch(
c.Ctx(),
&pfs.CreateBranchRequest{
Branch: NewBranch(repoName, branch),
... | go | {
"resource": ""
} |
q177422 | InspectBranch | test | func (c APIClient) InspectBranch(repoName string, branch string) (*pfs.BranchInfo, error) {
branchInfo, err := c.PfsAPIClient.InspectBranch(
c.Ctx(),
&pfs.InspectBranchRequest{
Branch: NewBranch(repoName, branch),
},
)
return branchInfo, grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177423 | ListBranch | test | func (c APIClient) ListBranch(repoName string) ([]*pfs.BranchInfo, error) {
branchInfos, err := c.PfsAPIClient.ListBranch(
c.Ctx(),
&pfs.ListBranchRequest{
Repo: NewRepo(repoName),
},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return branchInfos.BranchInfo, nil
} | go | {
"resource": ""
} |
q177424 | SetBranch | test | func (c APIClient) SetBranch(repoName string, commit string, branch string) error {
return c.CreateBranch(repoName, branch, commit, nil)
} | go | {
"resource": ""
} |
q177425 | DeleteBranch | test | func (c APIClient) DeleteBranch(repoName string, branch string, force bool) error {
_, err := c.PfsAPIClient.DeleteBranch(
c.Ctx(),
&pfs.DeleteBranchRequest{
Branch: NewBranch(repoName, branch),
Force: force,
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177426 | DeleteCommit | test | func (c APIClient) DeleteCommit(repoName string, commitID string) error {
_, err := c.PfsAPIClient.DeleteCommit(
c.Ctx(),
&pfs.DeleteCommitRequest{
Commit: NewCommit(repoName, commitID),
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177427 | FlushCommit | test | func (c APIClient) FlushCommit(commits []*pfs.Commit, toRepos []*pfs.Repo) (CommitInfoIterator, error) {
ctx, cancel := context.WithCancel(c.Ctx())
stream, err := c.PfsAPIClient.FlushCommit(
ctx,
&pfs.FlushCommitRequest{
Commits: commits,
ToRepos: toRepos,
},
)
if err != nil {
cancel()
return nil, g... | go | {
"resource": ""
} |
q177428 | FlushCommitF | test | func (c APIClient) FlushCommitF(commits []*pfs.Commit, toRepos []*pfs.Repo, f func(*pfs.CommitInfo) error) error {
stream, err := c.PfsAPIClient.FlushCommit(
c.Ctx(),
&pfs.FlushCommitRequest{
Commits: commits,
ToRepos: toRepos,
},
)
if err != nil {
return grpcutil.ScrubGRPC(err)
}
for {
ci, err := ... | go | {
"resource": ""
} |
q177429 | FlushCommitAll | test | func (c APIClient) FlushCommitAll(commits []*pfs.Commit, toRepos []*pfs.Repo) ([]*pfs.CommitInfo, error) {
var result []*pfs.CommitInfo
if err := c.FlushCommitF(commits, toRepos, func(ci *pfs.CommitInfo) error {
result = append(result, ci)
return nil
}); err != nil {
return nil, err
}
return result, nil
} | go | {
"resource": ""
} |
q177430 | SubscribeCommit | test | func (c APIClient) SubscribeCommit(repo string, branch string, from string, state pfs.CommitState) (CommitInfoIterator, error) {
ctx, cancel := context.WithCancel(c.Ctx())
req := &pfs.SubscribeCommitRequest{
Repo: NewRepo(repo),
Branch: branch,
State: state,
}
if from != "" {
req.From = NewCommit(repo, f... | go | {
"resource": ""
} |
q177431 | SubscribeCommitF | test | func (c APIClient) SubscribeCommitF(repo, branch, from string, state pfs.CommitState, f func(*pfs.CommitInfo) error) error {
req := &pfs.SubscribeCommitRequest{
Repo: NewRepo(repo),
Branch: branch,
State: state,
}
if from != "" {
req.From = NewCommit(repo, from)
}
stream, err := c.PfsAPIClient.Subscribe... | go | {
"resource": ""
} |
q177432 | PutObjectAsync | test | func (c APIClient) PutObjectAsync(tags []*pfs.Tag) (*PutObjectWriteCloserAsync, error) {
w, err := c.newPutObjectWriteCloserAsync(tags)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return w, nil
} | go | {
"resource": ""
} |
q177433 | PutObject | test | func (c APIClient) PutObject(_r io.Reader, tags ...string) (object *pfs.Object, _ int64, retErr error) {
r := grpcutil.ReaderWrapper{_r}
w, err := c.newPutObjectWriteCloser(tags...)
if err != nil {
return nil, 0, grpcutil.ScrubGRPC(err)
}
defer func() {
if err := w.Close(); err != nil && retErr == nil {
ret... | go | {
"resource": ""
} |
q177434 | PutObjectSplit | test | func (c APIClient) PutObjectSplit(_r io.Reader) (objects []*pfs.Object, _ int64, retErr error) {
r := grpcutil.ReaderWrapper{_r}
w, err := c.newPutObjectSplitWriteCloser()
if err != nil {
return nil, 0, grpcutil.ScrubGRPC(err)
}
defer func() {
if err := w.Close(); err != nil && retErr == nil {
retErr = grpc... | go | {
"resource": ""
} |
q177435 | GetObject | test | func (c APIClient) GetObject(hash string, writer io.Writer) error {
getObjectClient, err := c.ObjectAPIClient.GetObject(
c.Ctx(),
&pfs.Object{Hash: hash},
)
if err != nil {
return grpcutil.ScrubGRPC(err)
}
if err := grpcutil.WriteFromStreamingBytesClient(getObjectClient, writer); err != nil {
return grpcut... | go | {
"resource": ""
} |
q177436 | GetObjectReader | test | func (c APIClient) GetObjectReader(hash string) (io.ReadCloser, error) {
ctx, cancel := context.WithCancel(c.Ctx())
getObjectClient, err := c.ObjectAPIClient.GetObject(
ctx,
&pfs.Object{Hash: hash},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return grpcutil.NewStreamingBytesReader(getObjectClie... | go | {
"resource": ""
} |
q177437 | GetObjects | test | func (c APIClient) GetObjects(hashes []string, offset uint64, size uint64, totalSize uint64, writer io.Writer) error {
var objects []*pfs.Object
for _, hash := range hashes {
objects = append(objects, &pfs.Object{Hash: hash})
}
getObjectsClient, err := c.ObjectAPIClient.GetObjects(
c.Ctx(),
&pfs.GetObjectsReq... | go | {
"resource": ""
} |
q177438 | TagObject | test | func (c APIClient) TagObject(hash string, tags ...string) error {
var _tags []*pfs.Tag
for _, tag := range tags {
_tags = append(_tags, &pfs.Tag{Name: tag})
}
if _, err := c.ObjectAPIClient.TagObject(
c.Ctx(),
&pfs.TagObjectRequest{
Object: &pfs.Object{Hash: hash},
Tags: _tags,
},
); err != nil {
... | go | {
"resource": ""
} |
q177439 | ListObject | test | func (c APIClient) ListObject(f func(*pfs.Object) error) error {
listObjectClient, err := c.ObjectAPIClient.ListObjects(c.Ctx(), &pfs.ListObjectsRequest{})
if err != nil {
return grpcutil.ScrubGRPC(err)
}
for {
object, err := listObjectClient.Recv()
if err != nil {
if err == io.EOF {
return nil
}
... | go | {
"resource": ""
} |
q177440 | InspectObject | test | func (c APIClient) InspectObject(hash string) (*pfs.ObjectInfo, error) {
value, err := c.ObjectAPIClient.InspectObject(
c.Ctx(),
&pfs.Object{Hash: hash},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return value, nil
} | go | {
"resource": ""
} |
q177441 | GetTag | test | func (c APIClient) GetTag(tag string, writer io.Writer) error {
getTagClient, err := c.ObjectAPIClient.GetTag(
c.Ctx(),
&pfs.Tag{Name: tag},
)
if err != nil {
return grpcutil.ScrubGRPC(err)
}
if err := grpcutil.WriteFromStreamingBytesClient(getTagClient, writer); err != nil {
return grpcutil.ScrubGRPC(err)... | go | {
"resource": ""
} |
q177442 | GetTagReader | test | func (c APIClient) GetTagReader(tag string) (io.ReadCloser, error) {
ctx, cancel := context.WithCancel(c.Ctx())
getTagClient, err := c.ObjectAPIClient.GetTag(
ctx,
&pfs.Tag{Name: tag},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return grpcutil.NewStreamingBytesReader(getTagClient, cancel), nil
... | go | {
"resource": ""
} |
q177443 | ListTag | test | func (c APIClient) ListTag(f func(*pfs.ListTagsResponse) error) error {
listTagClient, err := c.ObjectAPIClient.ListTags(c.Ctx(), &pfs.ListTagsRequest{IncludeObject: true})
if err != nil {
return grpcutil.ScrubGRPC(err)
}
for {
listTagResponse, err := listTagClient.Recv()
if err != nil {
if err == io.EOF {... | go | {
"resource": ""
} |
q177444 | Compact | test | func (c APIClient) Compact() error {
_, err := c.ObjectAPIClient.Compact(
c.Ctx(),
&types.Empty{},
)
return err
} | go | {
"resource": ""
} |
q177445 | NewPutFileClient | test | func (c APIClient) NewPutFileClient() (PutFileClient, error) {
pfc, err := c.PfsAPIClient.PutFile(c.Ctx())
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return &putFileClient{c: pfc}, nil
} | go | {
"resource": ""
} |
q177446 | PutFileOverwrite | test | func (c *putFileClient) PutFileOverwrite(repoName string, commitID string, path string, reader io.Reader, overwriteIndex int64) (_ int, retErr error) {
writer, err := c.newPutFileWriteCloser(repoName, commitID, path, pfs.Delimiter_NONE, 0, 0, 0, &pfs.OverwriteIndex{Index: overwriteIndex})
if err != nil {
return 0, ... | go | {
"resource": ""
} |
q177447 | Close | test | func (c *putFileClient) Close() error {
_, err := c.c.CloseAndRecv()
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177448 | CopyFile | test | func (c APIClient) CopyFile(srcRepo, srcCommit, srcPath, dstRepo, dstCommit, dstPath string, overwrite bool) error {
if _, err := c.PfsAPIClient.CopyFile(c.Ctx(),
&pfs.CopyFileRequest{
Src: NewFile(srcRepo, srcCommit, srcPath),
Dst: NewFile(dstRepo, dstCommit, dstPath),
Overwrite: overwrite,
}... | go | {
"resource": ""
} |
q177449 | GetFile | test | func (c APIClient) GetFile(repoName string, commitID string, path string, offset int64, size int64, writer io.Writer) error {
if c.limiter != nil {
c.limiter.Acquire()
defer c.limiter.Release()
}
apiGetFileClient, err := c.getFile(repoName, commitID, path, offset, size)
if err != nil {
return grpcutil.ScrubGR... | go | {
"resource": ""
} |
q177450 | GetFileReader | test | func (c APIClient) GetFileReader(repoName string, commitID string, path string, offset int64, size int64) (io.Reader, error) {
apiGetFileClient, err := c.getFile(repoName, commitID, path, offset, size)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return grpcutil.NewStreamingBytesReader(apiGetFileClient, ... | go | {
"resource": ""
} |
q177451 | GetFileReadSeeker | test | func (c APIClient) GetFileReadSeeker(repoName string, commitID string, path string) (io.ReadSeeker, error) {
fileInfo, err := c.InspectFile(repoName, commitID, path)
if err != nil {
return nil, err
}
reader, err := c.GetFileReader(repoName, commitID, path, 0, 0)
if err != nil {
return nil, err
}
return &getF... | go | {
"resource": ""
} |
q177452 | InspectFile | test | func (c APIClient) InspectFile(repoName string, commitID string, path string) (*pfs.FileInfo, error) {
return c.inspectFile(repoName, commitID, path)
} | go | {
"resource": ""
} |
q177453 | ListFile | test | func (c APIClient) ListFile(repoName string, commitID string, path string) ([]*pfs.FileInfo, error) {
var result []*pfs.FileInfo
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
} | go | {
"resource": ""
} |
q177454 | ListFileHistory | test | func (c APIClient) ListFileHistory(repoName string, commitID string, path string, history int64) ([]*pfs.FileInfo, error) {
var result []*pfs.FileInfo
if err := c.ListFileF(repoName, commitID, path, history, func(fi *pfs.FileInfo) error {
result = append(result, fi)
return nil
}); err != nil {
return nil, err
... | go | {
"resource": ""
} |
q177455 | ListFileF | test | func (c APIClient) ListFileF(repoName string, commitID string, path string, history int64, f func(fi *pfs.FileInfo) error) error {
fs, err := c.PfsAPIClient.ListFileStream(
c.Ctx(),
&pfs.ListFileRequest{
File: NewFile(repoName, commitID, path),
History: history,
},
)
if err != nil {
return grpcutil.... | go | {
"resource": ""
} |
q177456 | Walk | test | func (c APIClient) Walk(repoName string, commitID string, path string, f WalkFn) error {
fs, err := c.PfsAPIClient.WalkFile(
c.Ctx(),
&pfs.WalkFileRequest{File: NewFile(repoName, commitID, path)})
if err != nil {
return grpcutil.ScrubGRPC(err)
}
for {
fi, err := fs.Recv()
if err == io.EOF {
return nil
... | go | {
"resource": ""
} |
q177457 | DeleteFile | test | func (c APIClient) DeleteFile(repoName string, commitID string, path string) error {
_, err := c.PfsAPIClient.DeleteFile(
c.Ctx(),
&pfs.DeleteFileRequest{
File: NewFile(repoName, commitID, path),
},
)
return err
} | go | {
"resource": ""
} |
q177458 | Write | test | func (w *PutObjectWriteCloserAsync) Write(p []byte) (int, error) {
select {
case err := <-w.errChan:
if err != nil {
return 0, grpcutil.ScrubGRPC(err)
}
default:
for len(w.buf)+len(p) > cap(w.buf) {
// Write the bytes that fit into w.buf, then
// remove those bytes from p.
i := cap(w.buf) - len(w.b... | go | {
"resource": ""
} |
q177459 | Close | test | func (w *PutObjectWriteCloserAsync) Close() error {
w.writeChan <- w.buf
close(w.writeChan)
err := <-w.errChan
if err != nil {
return grpcutil.ScrubGRPC(err)
}
w.object, err = w.client.CloseAndRecv()
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177460 | PrettyPrintVersionNoAdditional | test | func PrettyPrintVersionNoAdditional(version *pb.Version) string {
return fmt.Sprintf("%d.%d.%d", version.Major, version.Minor, version.Micro)
} | go | {
"resource": ""
} |
q177461 | recursiveBlockQuoteExamples | test | func recursiveBlockQuoteExamples(parent *cobra.Command) {
if parent.Example != "" {
parent.Example = fmt.Sprintf("```sh\n%s\n```", parent.Example)
}
for _, cmd := range parent.Commands() {
recursiveBlockQuoteExamples(cmd)
}
} | go | {
"resource": ""
} |
q177462 | errMissingField | test | func errMissingField(field string) *logical.Response {
return logical.ErrorResponse(fmt.Sprintf("missing required field '%s'", field))
} | go | {
"resource": ""
} |
q177463 | validateFields | test | func validateFields(req *logical.Request, data *framework.FieldData) error {
var unknownFields []string
for k := range req.Data {
if _, ok := data.Schema[k]; !ok {
unknownFields = append(unknownFields, k)
}
}
if len(unknownFields) > 0 {
return fmt.Errorf("unknown fields: %q", unknownFields)
}
return ni... | go | {
"resource": ""
} |
q177464 | putConfig | test | func putConfig(ctx context.Context, s logical.Storage, cfg *config) error {
entry, err := logical.StorageEntryJSON("config", cfg)
if err != nil {
return fmt.Errorf("%v: failed to generate storage entry", err)
}
if err := s.Put(ctx, entry); err != nil {
return fmt.Errorf("%v: failed to write configuration to sto... | go | {
"resource": ""
} |
q177465 | getConfig | test | func getConfig(ctx context.Context, s logical.Storage) (*config, error) {
entry, err := s.Get(ctx, "config")
if err != nil {
return nil, fmt.Errorf("%v: failed to get config from storage", err)
}
if entry == nil || len(entry.Value) == 0 {
return nil, errors.New("no configuration in storage")
}
var result con... | go | {
"resource": ""
} |
q177466 | Serve | test | func Serve(
servers ...ServerOptions,
) (retErr error) {
for _, server := range servers {
if server.RegisterFunc == nil {
return ErrMustSpecifyRegisterFunc
}
if server.Port == 0 {
return ErrMustSpecifyPort
}
opts := []grpc.ServerOption{
grpc.MaxConcurrentStreams(math.MaxUint32),
grpc.MaxRecvMsgS... | go | {
"resource": ""
} |
q177467 | NewPuller | test | func NewPuller() *Puller {
return &Puller{
errCh: make(chan error, 1),
pipes: make(map[string]bool),
}
} | go | {
"resource": ""
} |
q177468 | PullTree | test | func (p *Puller) PullTree(client *pachclient.APIClient, root string, tree hashtree.HashTree, pipes bool, concurrency int) error {
limiter := limit.New(concurrency)
var eg errgroup.Group
if err := tree.Walk("/", func(path string, node *hashtree.NodeProto) error {
if node.FileNode != nil {
path := filepath.Join(r... | go | {
"resource": ""
} |
q177469 | Push | test | func Push(client *pachclient.APIClient, root string, commit *pfs.Commit, overwrite bool) error {
var g errgroup.Group
if err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
g.Go(func() (retErr error) {
if path == root || info.IsDir() {
return nil
}
f, err := os.Open(path)... | go | {
"resource": ""
} |
q177470 | PushObj | test | func PushObj(pachClient *pachclient.APIClient, commit *pfs.Commit, objClient obj.Client, root string) error {
var eg errgroup.Group
sem := make(chan struct{}, 200)
if err := pachClient.Walk(commit.Repo.Name, commit.ID, "", func(fileInfo *pfs.FileInfo) error {
if fileInfo.FileType != pfs.FileType_FILE {
return n... | go | {
"resource": ""
} |
q177471 | PushFile | test | func PushFile(c *pachclient.APIClient, pfc pachclient.PutFileClient, pfsFile *pfs.File, osFile io.ReadSeeker) error {
fileInfo, err := c.InspectFile(pfsFile.Commit.Repo.Name, pfsFile.Commit.ID, pfsFile.Path)
if err != nil && !isNotExist(err) {
return err
}
var i int
var object *pfs.Object
if fileInfo != nil {
... | go | {
"resource": ""
} |
q177472 | Dump | test | func (c APIClient) Dump(w io.Writer) error {
goroClient, err := c.DebugClient.Dump(c.Ctx(), &debug.DumpRequest{})
if err != nil {
return grpcutil.ScrubGRPC(err)
}
return grpcutil.ScrubGRPC(grpcutil.WriteFromStreamingBytesClient(goroClient, w))
} | go | {
"resource": ""
} |
q177473 | Profile | test | func (c APIClient) Profile(profile string, duration time.Duration, w io.Writer) error {
var d *types.Duration
if duration != 0 {
d = types.DurationProto(duration)
}
profileClient, err := c.DebugClient.Profile(c.Ctx(), &debug.ProfileRequest{
Profile: profile,
Duration: d,
})
if err != nil {
return grpcuti... | go | {
"resource": ""
} |
q177474 | Binary | test | func (c APIClient) Binary(w io.Writer) error {
binaryClient, err := c.DebugClient.Binary(c.Ctx(), &debug.BinaryRequest{})
if err != nil {
return grpcutil.ScrubGRPC(err)
}
return grpcutil.ScrubGRPC(grpcutil.WriteFromStreamingBytesClient(binaryClient, w))
} | go | {
"resource": ""
} |
q177475 | RegisterCacheStats | test | func RegisterCacheStats(cacheName string, groupCacheStats *groupcache.Stats) {
c := &cacheStats{
cacheName: cacheName,
descriptions: make(map[string]*prometheus.Desc),
stats: groupCacheStats,
}
if err := prometheus.Register(c); err != nil {
// metrics may be redundantly registered; ignore these err... | go | {
"resource": ""
} |
q177476 | wait | test | func (c *counter) wait(n int64) {
c.mu.Lock()
defer c.mu.Unlock()
for c.n < n {
c.cond.Wait()
}
} | go | {
"resource": ""
} |
q177477 | RunWorkload | test | func RunWorkload(
client *client.APIClient,
rand *rand.Rand,
size int,
) error {
worker := newWorker(rand)
for i := 0; i < size; i++ {
if err := worker.work(client); err != nil {
return err
}
}
for _, job := range worker.startedJobs {
jobInfo, err := client.InspectJob(job.ID, true)
if err != nil {
... | go | {
"resource": ""
} |
q177478 | createRepo | test | func (w *worker) createRepo(c *client.APIClient) error {
repoName := w.randString(10)
if err := c.CreateRepo(repoName); err != nil {
return err
}
w.repos = append(w.repos, &pfs.Repo{Name: repoName})
// Start the first commit in the repo (no parent). This is critical to
// advanceCommit(), which will try to fin... | go | {
"resource": ""
} |
q177479 | advanceCommit | test | func (w *worker) advanceCommit(c *client.APIClient) error {
if len(w.started) >= maxStartedCommits || len(w.finished) == 0 {
// Randomly select a commit that has been started and finish it
if len(w.started) == 0 {
return nil
}
i := w.rand.Intn(len(w.started))
commit := w.started[i]
// Before we finish ... | go | {
"resource": ""
} |
q177480 | RandString | test | func RandString(r *rand.Rand, n int) string {
b := make([]byte, n)
for i := range b {
b[i] = letters[r.Intn(len(letters))]
}
return string(b)
} | go | {
"resource": ""
} |
q177481 | NewReader | test | func NewReader(rand *rand.Rand, bytes int64) io.Reader {
return &reader{
rand: rand,
bytes: bytes,
}
} | go | {
"resource": ""
} |
q177482 | iterDir | test | func iterDir(tx *bolt.Tx, path string, f func(k, v []byte, c *bolt.Cursor) error) error {
node, err := get(tx, path)
if err != nil {
return err
}
if node.DirNode == nil {
return errorf(PathConflict, "the file at \"%s\" is not a directory",
path)
}
c := NewChildCursor(tx, path)
for k, v := c.K(), c.V(); k ... | go | {
"resource": ""
} |
q177483 | FSSize | test | func (h *dbHashTree) FSSize() int64 {
rootNode, err := h.Get("/")
if err != nil {
return 0
}
return rootNode.SubtreeSize
} | go | {
"resource": ""
} |
q177484 | Diff | test | func (h *dbHashTree) Diff(oldHashTree HashTree, newPath string, oldPath string, recursiveDepth int64, f func(path string, node *NodeProto, new bool) error) (retErr error) {
// Setup a txn for each hashtree, this is a bit complicated because we don't want to make 2 read tx to the same tree, if we did then should someon... | go | {
"resource": ""
} |
q177485 | Serialize | test | func (h *dbHashTree) Serialize(_w io.Writer) error {
w := pbutil.NewWriter(_w)
return h.View(func(tx *bolt.Tx) error {
for _, bucket := range buckets {
b := tx.Bucket(b(bucket))
if _, err := w.Write(
&BucketHeader{
Bucket: bucket,
}); err != nil {
return err
}
if err := b.ForEach(func(k... | go | {
"resource": ""
} |
q177486 | Deserialize | test | func (h *dbHashTree) Deserialize(_r io.Reader) error {
r := pbutil.NewReader(_r)
hdr := &BucketHeader{}
batchSize := 10000
kvs := make(chan *keyValue, batchSize/10)
// create cancellable ctx in case bolt writer encounters error
eg, copyCtx := errgroup.WithContext(context.Background())
eg.Go(func() error {
var... | go | {
"resource": ""
} |
q177487 | Copy | test | func (h *dbHashTree) Copy() (HashTree, error) {
if err := h.Hash(); err != nil {
return nil, err
}
r, w := io.Pipe()
var eg errgroup.Group
eg.Go(func() (retErr error) {
defer func() {
if err := w.Close(); err != nil && retErr == nil {
retErr = err
}
}()
return h.Serialize(w)
})
var result HashT... | go | {
"resource": ""
} |
q177488 | Destroy | test | func (h *dbHashTree) Destroy() error {
path := h.Path()
if err := h.Close(); err != nil {
return err
}
return os.Remove(path)
} | go | {
"resource": ""
} |
q177489 | PutFileOverwrite | test | func (h *dbHashTree) PutFileOverwrite(path string, objects []*pfs.Object, overwriteIndex *pfs.OverwriteIndex, sizeDelta int64) error {
return h.putFile(path, objects, overwriteIndex, sizeDelta, false)
} | go | {
"resource": ""
} |
q177490 | PutDirHeaderFooter | test | func (h *dbHashTree) PutDirHeaderFooter(path string, header, footer *pfs.Object, headerSize, footerSize int64) error {
path = clean(path)
return h.Batch(func(tx *bolt.Tx) error {
// validation: 'path' must point to directory (or nothing--may not be
// created yet)
node, err := get(tx, path)
if err != nil && C... | go | {
"resource": ""
} |
q177491 | PutFileHeaderFooter | test | func (h *dbHashTree) PutFileHeaderFooter(path string, objects []*pfs.Object, size int64) error {
return h.putFile(path, objects, nil, size, true)
} | go | {
"resource": ""
} |
q177492 | deleteDir | test | func deleteDir(tx *bolt.Tx, path string) error {
c := fs(tx).Cursor()
prefix := append(b(path), nullByte[0])
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))
} | go | {
"resource": ""
} |
q177493 | NewReader | test | func NewReader(r io.Reader, filter Filter) *Reader {
return &Reader{
pbr: pbutil.NewReader(r),
filter: filter,
}
} | go | {
"resource": ""
} |
q177494 | Read | test | func (r *Reader) Read() (*MergeNode, error) {
_k, err := r.pbr.ReadBytes()
if err != nil {
return nil, err
}
if r.filter != nil {
for {
if r.filter(_k) {
break
}
_, err = r.pbr.ReadBytes()
if err != nil {
return nil, err
}
_k, err = r.pbr.ReadBytes()
if err != nil {
return nil, ... | go | {
"resource": ""
} |
q177495 | NewWriter | test | func NewWriter(w io.Writer) *Writer {
return &Writer{
pbw: pbutil.NewWriter(w),
}
} | go | {
"resource": ""
} |
q177496 | Write | test | func (w *Writer) Write(n *MergeNode) error {
// Marshal node if it was merged
if n.nodeProto != nil {
var err error
n.v, err = n.nodeProto.Marshal()
if err != nil {
return err
}
}
// Get size info from root node
if bytes.Equal(n.k, nullByte) {
if n.nodeProto == nil {
n.nodeProto = &NodeProto{}
i... | go | {
"resource": ""
} |
q177497 | Copy | test | func (w *Writer) Copy(r *Reader) error {
for {
n, err := r.Read()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if err := w.Write(n); err != nil {
return err
}
}
} | go | {
"resource": ""
} |
q177498 | Index | test | func (w *Writer) Index() ([]byte, error) {
buf := &bytes.Buffer{}
pbw := pbutil.NewWriter(buf)
for _, idx := range w.idxs {
if _, err := pbw.Write(idx); err != nil {
return nil, err
}
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q177499 | GetRangeFromIndex | test | func GetRangeFromIndex(r io.Reader, prefix string) (uint64, uint64, error) {
prefix = clean(prefix)
pbr := pbutil.NewReader(r)
idx := &Index{}
k := b(prefix)
var lower, upper uint64
iter := func(f func(int) bool) error {
for {
if err := pbr.Read(idx); err != nil {
if err == io.EOF {
break
}
... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.