_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q177500 | NewFilter | test | func NewFilter(numTrees int64, tree int64) Filter {
return func(k []byte) bool {
if pathToTree(k, numTrees) == uint64(tree) {
return true
}
return false
}
} | go | {
"resource": ""
} |
q177501 | PathToTree | test | func PathToTree(path string, numTrees int64) uint64 {
path = clean(path)
return pathToTree(b(path), numTrees)
} | go | {
"resource": ""
} |
q177502 | Merge | test | func Merge(w *Writer, rs []*Reader) error {
if len(rs) == 0 {
return nil
}
mq := &mergePQ{q: make([]*nodeStream, len(rs)+1)}
// Setup first set of nodes
for _, r := range rs {
if err := mq.insert(&nodeStream{r: r}); err != nil {
return err
}
}
for mq.q[1] != nil {
// Get next nodes to merge
ns, err ... | go | {
"resource": ""
} |
q177503 | Hash | test | func (h *dbHashTree) Hash() error {
return h.Batch(func(tx *bolt.Tx) error {
return canonicalize(tx, "")
})
} | go | {
"resource": ""
} |
q177504 | IsGlob | test | func IsGlob(pattern string) bool {
pattern = clean(pattern)
return globRegex.Match([]byte(pattern))
} | go | {
"resource": ""
} |
q177505 | GlobLiteralPrefix | test | func GlobLiteralPrefix(pattern string) string {
pattern = clean(pattern)
idx := globRegex.FindStringIndex(pattern)
if idx == nil {
return pattern
}
return pattern[:idx[0]]
} | go | {
"resource": ""
} |
q177506 | GetHashTreeObject | test | func GetHashTreeObject(pachClient *client.APIClient, storageRoot string, treeRef *pfs.Object) (HashTree, error) {
return getHashTree(storageRoot, func(w io.Writer) error {
return pachClient.GetObject(treeRef.Hash, w)
})
} | go | {
"resource": ""
} |
q177507 | GetHashTreeTag | test | func GetHashTreeTag(pachClient *client.APIClient, storageRoot string, treeRef *pfs.Tag) (HashTree, error) {
return getHashTree(storageRoot, func(w io.Writer) error {
return pachClient.GetTag(treeRef.Name, w)
})
} | go | {
"resource": ""
} |
q177508 | PutHashTree | test | func PutHashTree(pachClient *client.APIClient, tree HashTree, tags ...string) (*pfs.Object, error) {
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 tree.Serialize(w)
})
var treeRef *pf... | go | {
"resource": ""
} |
q177509 | NewChildCursor | test | func NewChildCursor(tx *bolt.Tx, path string) *ChildCursor {
path = clean(path)
c := fs(tx).Cursor()
dir := b(path)
k, v := c.Seek(append(dir, nullByte[0]))
if !bytes.Equal(dir, nullByte) {
dir = append(dir, nullByte[0])
}
if !bytes.HasPrefix(k, dir) {
k, v = nil, nil
}
return &ChildCursor{
c: c,
dir... | go | {
"resource": ""
} |
q177510 | Next | test | func (d *ChildCursor) Next() ([]byte, []byte) {
if d.k == nil {
return nil, nil
}
k, v := d.c.Seek(append(d.k, 1))
if !bytes.HasPrefix(k, d.dir) {
k, v = nil, nil
}
d.k, d.v = k, v
return k, v
} | go | {
"resource": ""
} |
q177511 | NewOrdered | test | func NewOrdered(root string) *Ordered {
root = clean(root)
o := &Ordered{}
n := &node{
path: "",
nodeProto: &NodeProto{
Name: "",
DirNode: &DirectoryNodeProto{},
},
hash: sha256.New(),
}
o.fs = append(o.fs, n)
o.dirStack = append(o.dirStack, n)
o.MkdirAll(root)
o.root = root
return o
} | go | {
"resource": ""
} |
q177512 | MkdirAll | test | func (o *Ordered) MkdirAll(path string) {
var paths []string
for path != "" {
paths = append(paths, path)
path, _ = split(path)
}
for i := len(paths) - 1; i >= 0; i-- {
o.PutDir(paths[i])
}
} | go | {
"resource": ""
} |
q177513 | PutDir | test | func (o *Ordered) PutDir(path string) {
path = clean(path)
if path == "" {
return
}
nodeProto := &NodeProto{
Name: base(path),
DirNode: &DirectoryNodeProto{},
}
o.putDir(path, nodeProto)
} | go | {
"resource": ""
} |
q177514 | Serialize | test | func (o *Ordered) Serialize(_w io.Writer) error {
w := NewWriter(_w)
// Unwind directory stack
for len(o.dirStack) > 1 {
child := o.dirStack[len(o.dirStack)-1]
child.nodeProto.Hash = child.hash.Sum(nil)
o.dirStack = o.dirStack[:len(o.dirStack)-1]
parent := o.dirStack[len(o.dirStack)-1]
parent.hash.Write([]... | go | {
"resource": ""
} |
q177515 | NewUnordered | test | func NewUnordered(root string) *Unordered {
return &Unordered{
fs: make(map[string]*NodeProto),
root: clean(root),
}
} | go | {
"resource": ""
} |
q177516 | Ordered | test | func (u *Unordered) Ordered() *Ordered {
paths := make([]string, len(u.fs))
i := 0
for path := range u.fs {
paths[i] = path
i++
}
sort.Strings(paths)
o := NewOrdered("")
for i := 1; i < len(paths); i++ {
path := paths[i]
n := u.fs[path]
if n.DirNode != nil {
o.putDir(path, n)
} else {
o.putFile... | go | {
"resource": ""
} |
q177517 | revokeUserCredentials | test | func revokeUserCredentials(ctx context.Context, pachdAddress string, userToken string, adminToken string) error {
// Setup a single use client w the given admin token / address
client, err := pclient.NewFromAddress(pachdAddress)
if err != nil {
return err
}
defer client.Close() // avoid leaking connections
cli... | go | {
"resource": ""
} |
q177518 | NewAPIServer | test | func NewAPIServer(version *pb.Version, options APIServerOptions) pb.APIServer {
return newAPIServer(version, options)
} | go | {
"resource": ""
} |
q177519 | String | test | func String(v *pb.Version) string {
return fmt.Sprintf("%d.%d.%d%s", v.Major, v.Minor, v.Micro, v.Additional)
} | go | {
"resource": ""
} |
q177520 | getPipelineInfo | test | func getPipelineInfo(pachClient *client.APIClient, env *serviceenv.ServiceEnv) (*pps.PipelineInfo, error) {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
resp, err := env.GetEtcdClient().Get(ctx, path.Join(env.PPSEtcdPrefix, "pipelines", env.PPSPipelineName))
if err != nil ... | go | {
"resource": ""
} |
q177521 | removeStr | test | func removeStr(ss *[]string, s string) bool {
idx := sort.SearchStrings(*ss, s)
if idx == len(*ss) {
return false
}
copy((*ss)[idx:], (*ss)[idx+1:])
*ss = (*ss)[:len(*ss)-1]
return true
} | go | {
"resource": ""
} |
q177522 | PublicCertToPEM | test | func PublicCertToPEM(cert *tls.Certificate) []byte {
return pem.EncodeToMemory(&pem.Block{
Type: "CERTIFICATE",
Bytes: cert.Certificate[0],
})
} | go | {
"resource": ""
} |
q177523 | GenerateSelfSignedCert | test | func GenerateSelfSignedCert(address string, name *pkix.Name, ipAddresses ...string) (*tls.Certificate, error) {
// Generate Subject Distinguished Name
if name == nil {
name = &pkix.Name{}
}
switch {
case address == "" && name.CommonName == "":
return nil, errors.New("must set either \"address\" or \"name.Commo... | go | {
"resource": ""
} |
q177524 | ActivateCmd | test | func ActivateCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
var initialAdmin string
activate := &cobra.Command{
Short: "Activate Pachyderm's auth system",
Long: `
Activate Pachyderm's auth system, and restrict access to existing data to the
user running the command (or the argument to --initial-admin), w... | go | {
"resource": ""
} |
q177525 | DeactivateCmd | test | func DeactivateCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
deactivate := &cobra.Command{
Short: "Delete all ACLs, tokens, and admins, and deactivate Pachyderm auth",
Long: "Deactivate Pachyderm's auth system, which will delete ALL auth " +
"tokens, ACLs and admins, and expose all data in the cluster... | go | {
"resource": ""
} |
q177526 | LoginCmd | test | func LoginCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
var useOTP bool
login := &cobra.Command{
Short: "Log in to Pachyderm",
Long: "Login to Pachyderm. Any resources that have been restricted to " +
"the account you have with your ID provider (e.g. GitHub, Okta) " +
"account will subsequently be... | go | {
"resource": ""
} |
q177527 | LogoutCmd | test | func LogoutCmd() *cobra.Command {
logout := &cobra.Command{
Short: "Log out of Pachyderm by deleting your local credential",
Long: "Log out of Pachyderm by deleting your local credential. Note that " +
"it's not necessary to log out before logging in with another account " +
"(simply run 'pachctl auth login'... | go | {
"resource": ""
} |
q177528 | WhoamiCmd | test | func WhoamiCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
whoami := &cobra.Command{
Short: "Print your Pachyderm identity",
Long: "Print your Pachyderm identity.",
Run: cmdutil.Run(func([]string) error {
c, err := client.NewOnUserMachine(!*noMetrics, !*noPortForwarding, "user")
if err != nil {
... | go | {
"resource": ""
} |
q177529 | CheckCmd | test | func CheckCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
check := &cobra.Command{
Use: "{{alias}} (none|reader|writer|owner) <repo>",
Short: "Check whether you have reader/writer/etc-level access to 'repo'",
Long: "Check whether you have reader/writer/etc-level access to 'repo'. " +
"For example, '... | go | {
"resource": ""
} |
q177530 | GetCmd | test | func GetCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
get := &cobra.Command{
Use: "{{alias}} [<username>] <repo>",
Short: "Get the ACL for 'repo' or the access that 'username' has to 'repo'",
Long: "Get the ACL for 'repo' or the access that 'username' has to " +
"'repo'. For example, 'pachctl auth... | go | {
"resource": ""
} |
q177531 | SetScopeCmd | test | func SetScopeCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
setScope := &cobra.Command{
Use: "{{alias}} <username> (none|reader|writer|owner) <repo>",
Short: "Set the scope of access that 'username' has to 'repo'",
Long: "Set the scope of access that 'username' has to 'repo'. For " +
"example, 'pac... | go | {
"resource": ""
} |
q177532 | ListAdminsCmd | test | func ListAdminsCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
listAdmins := &cobra.Command{
Short: "List the current cluster admins",
Long: "List the current cluster admins",
Run: cmdutil.Run(func([]string) error {
c, err := client.NewOnUserMachine(!*noMetrics, !*noPortForwarding, "user")
if err ... | go | {
"resource": ""
} |
q177533 | ModifyAdminsCmd | test | func ModifyAdminsCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
var add []string
var remove []string
modifyAdmins := &cobra.Command{
Short: "Modify the current cluster admins",
Long: "Modify the current cluster admins. --add accepts a comma-" +
"separated list of users to grant admin status, and --re... | go | {
"resource": ""
} |
q177534 | GetAuthTokenCmd | test | func GetAuthTokenCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
var quiet bool
getAuthToken := &cobra.Command{
Use: "{{alias}} <username>",
Short: "Get an auth token that authenticates the holder as \"username\"",
Long: "Get an auth token that authenticates the holder as \"username\"; " +
"this ca... | go | {
"resource": ""
} |
q177535 | UseAuthTokenCmd | test | func UseAuthTokenCmd() *cobra.Command {
useAuthToken := &cobra.Command{
Short: "Read a Pachyderm auth token from stdin, and write it to the " +
"current user's Pachyderm config file",
Long: "Read a Pachyderm auth token from stdin, and write it to the " +
"current user's Pachyderm config file",
Run: cmdutil... | go | {
"resource": ""
} |
q177536 | Cmds | test | func Cmds(noMetrics, noPortForwarding *bool) []*cobra.Command {
var commands []*cobra.Command
auth := &cobra.Command{
Short: "Auth commands manage access to data in a Pachyderm cluster",
Long: "Auth commands manage access to data in a Pachyderm cluster",
}
commands = append(commands, cmdutil.CreateAlias(auth... | go | {
"resource": ""
} |
q177537 | ParseScope | test | func ParseScope(s string) (Scope, error) {
for name, value := range Scope_value {
if strings.EqualFold(s, name) {
return Scope(value), nil
}
}
return Scope_NONE, fmt.Errorf("unrecognized scope: %s", s)
} | go | {
"resource": ""
} |
q177538 | IsErrNotActivated | test | func IsErrNotActivated(err error) bool {
if err == nil {
return false
}
// TODO(msteffen) This is unstructured because we have no way to propagate
// structured errors across GRPC boundaries. Fix
return strings.Contains(err.Error(), status.Convert(ErrNotActivated).Message())
} | go | {
"resource": ""
} |
q177539 | IsErrPartiallyActivated | test | func IsErrPartiallyActivated(err error) bool {
if err == nil {
return false
}
// TODO(msteffen) This is unstructured because we have no way to propagate
// structured errors across GRPC boundaries. Fix
return strings.Contains(err.Error(), status.Convert(ErrPartiallyActivated).Message())
} | go | {
"resource": ""
} |
q177540 | IsErrNotSignedIn | test | func IsErrNotSignedIn(err error) bool {
if err == nil {
return false
}
// TODO(msteffen) This is unstructured because we have no way to propagate
// structured errors across GRPC boundaries. Fix
return strings.Contains(err.Error(), status.Convert(ErrNotSignedIn).Message())
} | go | {
"resource": ""
} |
q177541 | IsErrBadToken | test | func IsErrBadToken(err error) bool {
if err == nil {
return false
}
return strings.Contains(err.Error(), status.Convert(ErrBadToken).Message())
} | go | {
"resource": ""
} |
q177542 | IsErrNotAuthorized | test | func IsErrNotAuthorized(err error) bool {
if err == nil {
return false
}
// TODO(msteffen) This is unstructured because we have no way to propagate
// structured errors across GRPC boundaries. Fix
return strings.Contains(err.Error(), errNotAuthorizedMsg)
} | go | {
"resource": ""
} |
q177543 | IsErrInvalidPrincipal | test | func IsErrInvalidPrincipal(err error) bool {
if err == nil {
return false
}
return strings.Contains(err.Error(), "invalid principal \"") &&
strings.Contains(err.Error(), "\"; must start with one of \"pipeline:\", \"github:\", or \"robot:\", or have no \":\"")
} | go | {
"resource": ""
} |
q177544 | IsErrTooShortTTL | test | func IsErrTooShortTTL(err error) bool {
if err == nil {
return false
}
errMsg := err.Error()
return strings.Contains(errMsg, "provided TTL (") &&
strings.Contains(errMsg, ") is shorter than token's existing TTL (") &&
strings.Contains(errMsg, ")")
} | go | {
"resource": ""
} |
q177545 | NewDatumFactory | test | func NewDatumFactory(pachClient *client.APIClient, input *pps.Input) (DatumFactory, error) {
switch {
case input.Pfs != nil:
return newPFSDatumFactory(pachClient, input.Pfs)
case input.Union != nil:
return newUnionDatumFactory(pachClient, input.Union)
case input.Cross != nil:
return newCrossDatumFactory(pachC... | go | {
"resource": ""
} |
q177546 | NewCollection | test | func NewCollection(etcdClient *etcd.Client, prefix string, indexes []*Index, template proto.Message, keyCheck func(string) error, valCheck func(proto.Message) error) Collection {
// We want to ensure that the prefix always ends with a trailing
// slash. Otherwise, when you list the items under a collection
// such ... | go | {
"resource": ""
} |
q177547 | Path | test | func (c *collection) Path(key string) string {
return path.Join(c.prefix, key)
} | go | {
"resource": ""
} |
q177548 | getIndexPath | test | func (c *readWriteCollection) getIndexPath(val interface{}, index *Index, key string) string {
reflVal := reflect.ValueOf(val)
field := reflect.Indirect(reflVal).FieldByName(index.Field).Interface()
return c.indexPath(index, field, key)
} | go | {
"resource": ""
} |
q177549 | getMultiIndexPaths | test | func (c *readWriteCollection) getMultiIndexPaths(val interface{}, index *Index, key string) []string {
var indexPaths []string
field := reflect.Indirect(reflect.ValueOf(val)).FieldByName(index.Field)
for i := 0; i < field.Len(); i++ {
indexPaths = append(indexPaths, c.indexPath(index, field.Index(i).Interface(), k... | go | {
"resource": ""
} |
q177550 | Upsert | test | func (c *readWriteCollection) Upsert(key string, val proto.Message, f func() error) error {
if err := watch.CheckType(c.template, val); err != nil {
return err
}
if err := c.Get(key, val); err != nil && !IsErrNotFound(err) {
return err
}
if err := f(); err != nil {
return err
}
return c.Put(key, val)
} | go | {
"resource": ""
} |
q177551 | get | test | func (c *readonlyCollection) get(key string, opts ...etcd.OpOption) (*etcd.GetResponse, error) {
span, ctx := tracing.AddSpanToAnyExisting(c.ctx, "etcd.Get")
defer tracing.FinishAnySpan(span)
resp, err := c.etcdClient.Get(ctx, key, opts...)
return resp, err
} | go | {
"resource": ""
} |
q177552 | List | test | func (c *readonlyCollection) List(val proto.Message, opts *Options, f func(string) error) error {
if err := watch.CheckType(c.template, val); err != nil {
return err
}
return c.list(c.prefix, &c.limit, opts, func(kv *mvccpb.KeyValue) error {
if err := proto.Unmarshal(kv.Value, val); err != nil {
return err
... | go | {
"resource": ""
} |
q177553 | Watch | test | func (c *readonlyCollection) Watch(opts ...watch.OpOption) (watch.Watcher, error) {
return watch.NewWatcher(c.ctx, c.etcdClient, c.prefix, c.prefix, c.template, opts...)
} | go | {
"resource": ""
} |
q177554 | WatchByIndex | test | func (c *readonlyCollection) WatchByIndex(index *Index, val interface{}) (watch.Watcher, error) {
eventCh := make(chan *watch.Event)
done := make(chan struct{})
watcher, err := watch.NewWatcher(c.ctx, c.etcdClient, c.prefix, c.indexDir(index, val), c.template)
if err != nil {
return nil, err
}
go func() (retErr... | go | {
"resource": ""
} |
q177555 | WatchOne | test | func (c *readonlyCollection) WatchOne(key string) (watch.Watcher, error) {
return watch.NewWatcher(c.ctx, c.etcdClient, c.prefix, c.Path(key), c.template)
} | go | {
"resource": ""
} |
q177556 | WatchOneF | test | func (c *readonlyCollection) WatchOneF(key string, f func(e *watch.Event) error) error {
watcher, err := watch.NewWatcher(c.ctx, c.etcdClient, c.prefix, c.Path(key), c.template)
if err != nil {
return err
}
defer watcher.Close()
for {
select {
case e := <-watcher.Watch():
if err := f(e); err != nil {
... | go | {
"resource": ""
} |
q177557 | Get | test | func (c *Cache) Get(key string) (io.ReadCloser, error) {
c.mu.Lock()
defer c.mu.Unlock()
if !c.keys[key] {
return nil, fmt.Errorf("key %v not found in cache", key)
}
f, err := os.Open(filepath.Join(c.root, key))
if err != nil {
return nil, err
}
return f, nil
} | go | {
"resource": ""
} |
q177558 | Keys | test | func (c *Cache) Keys() []string {
c.mu.Lock()
defer c.mu.Unlock()
var keys []string
for key := range c.keys {
keys = append(keys, key)
}
sort.Strings(keys)
return keys
} | go | {
"resource": ""
} |
q177559 | Clear | test | func (c *Cache) Clear() error {
c.mu.Lock()
defer c.mu.Unlock()
defer func() {
c.keys = make(map[string]bool)
}()
for key := range c.keys {
if err := os.Remove(filepath.Join(c.root, key)); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q177560 | NewHTTPServer | test | func NewHTTPServer(address string) (http.Handler, error) {
router := httprouter.New()
s := &server{
router: router,
address: address,
httpClient: &http.Client{},
}
router.GET(getFilePath, s.getFileHandler)
router.GET(servicePath, s.serviceHandler)
router.POST(loginPath, s.authLoginHandler)
router.... | go | {
"resource": ""
} |
q177561 | NewDeployServer | test | func NewDeployServer(kubeClient *kube.Clientset, kubeNamespace string) deploy.APIServer {
return &apiServer{
kubeClient: kubeClient,
kubeNamespace: kubeNamespace,
}
} | go | {
"resource": ""
} |
q177562 | Export | test | func Export(opts *assets.AssetOpts, out io.Writer) error {
client, err := docker.NewClientFromEnv()
if err != nil {
return err
}
authConfigs, err := docker.NewAuthConfigurationsFromDockerCfg()
if err != nil {
return fmt.Errorf("error parsing auth: %s, try running `docker login`", err.Error())
}
if len(authCo... | go | {
"resource": ""
} |
q177563 | Import | test | func Import(opts *assets.AssetOpts, in io.Reader) error {
client, err := docker.NewClientFromEnv()
if err != nil {
return err
}
authConfigs, err := docker.NewAuthConfigurationsFromDockerCfg()
if err != nil {
return fmt.Errorf("error parsing auth: %s, try running `docker login`", err.Error())
}
if len(authCon... | go | {
"resource": ""
} |
q177564 | DatumTagPrefix | test | func DatumTagPrefix(salt string) string {
// We need to hash the salt because UUIDs are not necessarily
// random in every bit.
h := sha256.New()
h.Write([]byte(salt))
return hex.EncodeToString(h.Sum(nil))[:4]
} | go | {
"resource": ""
} |
q177565 | NewPFSInput | test | func NewPFSInput(repo string, glob string) *pps.Input {
return &pps.Input{
Pfs: &pps.PFSInput{
Repo: repo,
Glob: glob,
},
}
} | go | {
"resource": ""
} |
q177566 | NewPFSInputOpts | test | func NewPFSInputOpts(name string, repo string, branch string, glob string, lazy bool) *pps.Input {
return &pps.Input{
Pfs: &pps.PFSInput{
Name: name,
Repo: repo,
Branch: branch,
Glob: glob,
Lazy: lazy,
},
}
} | go | {
"resource": ""
} |
q177567 | NewJobInput | test | func NewJobInput(repoName string, commitID string, glob string) *pps.JobInput {
return &pps.JobInput{
Commit: NewCommit(repoName, commitID),
Glob: glob,
}
} | go | {
"resource": ""
} |
q177568 | NewPipelineInput | test | func NewPipelineInput(repoName string, glob string) *pps.PipelineInput {
return &pps.PipelineInput{
Repo: NewRepo(repoName),
Glob: glob,
}
} | go | {
"resource": ""
} |
q177569 | CreateJob | test | func (c APIClient) CreateJob(pipeline string, outputCommit *pfs.Commit) (*pps.Job, error) {
job, err := c.PpsAPIClient.CreateJob(
c.Ctx(),
&pps.CreateJobRequest{
Pipeline: NewPipeline(pipeline),
OutputCommit: outputCommit,
},
)
return job, grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177570 | ListJob | test | func (c APIClient) ListJob(pipelineName string, inputCommit []*pfs.Commit, outputCommit *pfs.Commit) ([]*pps.JobInfo, error) {
var result []*pps.JobInfo
if err := c.ListJobF(pipelineName, inputCommit, outputCommit, func(ji *pps.JobInfo) error {
result = append(result, ji)
return nil
}); err != nil {
return nil... | go | {
"resource": ""
} |
q177571 | ListJobF | test | func (c APIClient) ListJobF(pipelineName string, inputCommit []*pfs.Commit, outputCommit *pfs.Commit, f func(*pps.JobInfo) error) error {
var pipeline *pps.Pipeline
if pipelineName != "" {
pipeline = NewPipeline(pipelineName)
}
client, err := c.PpsAPIClient.ListJobStream(
c.Ctx(),
&pps.ListJobRequest{
Pipe... | go | {
"resource": ""
} |
q177572 | FlushJob | test | func (c APIClient) FlushJob(commits []*pfs.Commit, toPipelines []string, f func(*pps.JobInfo) error) error {
req := &pps.FlushJobRequest{
Commits: commits,
}
for _, pipeline := range toPipelines {
req.ToPipelines = append(req.ToPipelines, NewPipeline(pipeline))
}
client, err := c.PpsAPIClient.FlushJob(c.Ctx(),... | go | {
"resource": ""
} |
q177573 | FlushJobAll | test | func (c APIClient) FlushJobAll(commits []*pfs.Commit, toPipelines []string) ([]*pps.JobInfo, error) {
var result []*pps.JobInfo
if err := c.FlushJob(commits, toPipelines, func(ji *pps.JobInfo) error {
result = append(result, ji)
return nil
}); err != nil {
return nil, err
}
return result, nil
} | go | {
"resource": ""
} |
q177574 | DeleteJob | test | func (c APIClient) DeleteJob(jobID string) error {
_, err := c.PpsAPIClient.DeleteJob(
c.Ctx(),
&pps.DeleteJobRequest{
Job: NewJob(jobID),
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177575 | StopJob | test | func (c APIClient) StopJob(jobID string) error {
_, err := c.PpsAPIClient.StopJob(
c.Ctx(),
&pps.StopJobRequest{
Job: NewJob(jobID),
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177576 | RestartDatum | test | func (c APIClient) RestartDatum(jobID string, datumFilter []string) error {
_, err := c.PpsAPIClient.RestartDatum(
c.Ctx(),
&pps.RestartDatumRequest{
Job: NewJob(jobID),
DataFilters: datumFilter,
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177577 | ListDatum | test | func (c APIClient) ListDatum(jobID string, pageSize int64, page int64) (*pps.ListDatumResponse, error) {
client, err := c.PpsAPIClient.ListDatumStream(
c.Ctx(),
&pps.ListDatumRequest{
Job: NewJob(jobID),
PageSize: pageSize,
Page: page,
},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err... | go | {
"resource": ""
} |
q177578 | ListDatumF | test | func (c APIClient) ListDatumF(jobID string, pageSize int64, page int64, f func(di *pps.DatumInfo) error) error {
client, err := c.PpsAPIClient.ListDatumStream(
c.Ctx(),
&pps.ListDatumRequest{
Job: NewJob(jobID),
PageSize: pageSize,
Page: page,
},
)
if err != nil {
return grpcutil.ScrubGRPC(... | go | {
"resource": ""
} |
q177579 | InspectDatum | test | func (c APIClient) InspectDatum(jobID string, datumID string) (*pps.DatumInfo, error) {
datumInfo, err := c.PpsAPIClient.InspectDatum(
c.Ctx(),
&pps.InspectDatumRequest{
Datum: &pps.Datum{
ID: datumID,
Job: NewJob(jobID),
},
},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return d... | go | {
"resource": ""
} |
q177580 | Next | test | func (l *LogsIter) Next() bool {
if l.err != nil {
l.msg = nil
return false
}
l.msg, l.err = l.logsClient.Recv()
if l.err != nil {
return false
}
return true
} | go | {
"resource": ""
} |
q177581 | InspectPipeline | test | func (c APIClient) InspectPipeline(pipelineName string) (*pps.PipelineInfo, error) {
pipelineInfo, err := c.PpsAPIClient.InspectPipeline(
c.Ctx(),
&pps.InspectPipelineRequest{
Pipeline: NewPipeline(pipelineName),
},
)
return pipelineInfo, grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177582 | ListPipeline | test | func (c APIClient) ListPipeline() ([]*pps.PipelineInfo, error) {
pipelineInfos, err := c.PpsAPIClient.ListPipeline(
c.Ctx(),
&pps.ListPipelineRequest{},
)
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return pipelineInfos.PipelineInfo, nil
} | go | {
"resource": ""
} |
q177583 | DeletePipeline | test | func (c APIClient) DeletePipeline(name string, force bool) error {
_, err := c.PpsAPIClient.DeletePipeline(
c.Ctx(),
&pps.DeletePipelineRequest{
Pipeline: NewPipeline(name),
Force: force,
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177584 | StartPipeline | test | func (c APIClient) StartPipeline(name string) error {
_, err := c.PpsAPIClient.StartPipeline(
c.Ctx(),
&pps.StartPipelineRequest{
Pipeline: NewPipeline(name),
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177585 | StopPipeline | test | func (c APIClient) StopPipeline(name string) error {
_, err := c.PpsAPIClient.StopPipeline(
c.Ctx(),
&pps.StopPipelineRequest{
Pipeline: NewPipeline(name),
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177586 | RerunPipeline | test | func (c APIClient) RerunPipeline(name string, include []*pfs.Commit, exclude []*pfs.Commit) error {
_, err := c.PpsAPIClient.RerunPipeline(
c.Ctx(),
&pps.RerunPipelineRequest{
Pipeline: NewPipeline(name),
Include: include,
Exclude: exclude,
},
)
return grpcutil.ScrubGRPC(err)
} | go | {
"resource": ""
} |
q177587 | CreatePipelineService | test | func (c APIClient) CreatePipelineService(
name string,
image string,
cmd []string,
stdin []string,
parallelismSpec *pps.ParallelismSpec,
input *pps.Input,
update bool,
internalPort int32,
externalPort int32,
) error {
_, err := c.PpsAPIClient.CreatePipeline(
c.Ctx(),
&pps.CreatePipelineRequest{
Pipelin... | go | {
"resource": ""
} |
q177588 | GetDatumTotalTime | test | func GetDatumTotalTime(s *pps.ProcessStats) time.Duration {
totalDuration := time.Duration(0)
duration, _ := types.DurationFromProto(s.DownloadTime)
totalDuration += duration
duration, _ = types.DurationFromProto(s.ProcessTime)
totalDuration += duration
duration, _ = types.DurationFromProto(s.UploadTime)
totalDu... | go | {
"resource": ""
} |
q177589 | Mount | test | func Mount(c *client.APIClient, mountPoint string, opts *Options) error {
nfs := pathfs.NewPathNodeFs(newFileSystem(c, opts.getCommits()), nil)
server, _, err := nodefs.MountRoot(mountPoint, nfs.Root(), opts.getFuse())
if err != nil {
return fmt.Errorf("nodefs.MountRoot: %v", err)
}
sigChan := make(chan os.Signa... | go | {
"resource": ""
} |
q177590 | NewBufPool | test | func NewBufPool(size int) *BufPool {
return &BufPool{sync.Pool{
New: func() interface{} { return make([]byte, size) },
}}
} | go | {
"resource": ""
} |
q177591 | StorageRootFromEnv | test | func StorageRootFromEnv() (string, error) {
storageRoot, ok := os.LookupEnv(PachRootEnvVar)
if !ok {
return "", fmt.Errorf("%s not found", PachRootEnvVar)
}
storageBackend, ok := os.LookupEnv(StorageBackendEnvVar)
if !ok {
return "", fmt.Errorf("%s not found", StorageBackendEnvVar)
}
// These storage backend... | go | {
"resource": ""
} |
q177592 | BlockPathFromEnv | test | func BlockPathFromEnv(block *pfs.Block) (string, error) {
storageRoot, err := StorageRootFromEnv()
if err != nil {
return "", err
}
return filepath.Join(storageRoot, "block", block.Hash), nil
} | go | {
"resource": ""
} |
q177593 | NewGoogleClient | test | func NewGoogleClient(bucket string, opts []option.ClientOption) (Client, error) {
return newGoogleClient(bucket, opts)
} | go | {
"resource": ""
} |
q177594 | NewGoogleClientFromSecret | test | func NewGoogleClientFromSecret(bucket string) (Client, error) {
var err error
if bucket == "" {
bucket, err = readSecretFile("/google-bucket")
if err != nil {
return nil, fmt.Errorf("google-bucket not found")
}
}
cred, err := readSecretFile("/google-cred")
if err != nil {
return nil, fmt.Errorf("google-... | go | {
"resource": ""
} |
q177595 | NewGoogleClientFromEnv | test | func NewGoogleClientFromEnv() (Client, error) {
bucket, ok := os.LookupEnv(GoogleBucketEnvVar)
if !ok {
return nil, fmt.Errorf("%s not found", GoogleBucketEnvVar)
}
creds, ok := os.LookupEnv(GoogleCredEnvVar)
if !ok {
return nil, fmt.Errorf("%s not found", GoogleCredEnvVar)
}
opts := []option.ClientOption{op... | go | {
"resource": ""
} |
q177596 | NewMicrosoftClientFromSecret | test | func NewMicrosoftClientFromSecret(container string) (Client, error) {
var err error
if container == "" {
container, err = readSecretFile("/microsoft-container")
if err != nil {
return nil, fmt.Errorf("microsoft-container not found")
}
}
id, err := readSecretFile("/microsoft-id")
if err != nil {
return n... | go | {
"resource": ""
} |
q177597 | NewMicrosoftClientFromEnv | test | func NewMicrosoftClientFromEnv() (Client, error) {
container, ok := os.LookupEnv(MicrosoftContainerEnvVar)
if !ok {
return nil, fmt.Errorf("%s not found", MicrosoftContainerEnvVar)
}
id, ok := os.LookupEnv(MicrosoftIDEnvVar)
if !ok {
return nil, fmt.Errorf("%s not found", MicrosoftIDEnvVar)
}
secret, ok := o... | go | {
"resource": ""
} |
q177598 | NewMinioClientFromSecret | test | func NewMinioClientFromSecret(bucket string) (Client, error) {
var err error
if bucket == "" {
bucket, err = readSecretFile("/minio-bucket")
if err != nil {
return nil, err
}
}
endpoint, err := readSecretFile("/minio-endpoint")
if err != nil {
return nil, err
}
id, err := readSecretFile("/minio-id")
... | go | {
"resource": ""
} |
q177599 | NewMinioClientFromEnv | test | func NewMinioClientFromEnv() (Client, error) {
bucket, ok := os.LookupEnv(MinioBucketEnvVar)
if !ok {
return nil, fmt.Errorf("%s not found", MinioBucketEnvVar)
}
endpoint, ok := os.LookupEnv(MinioEndpointEnvVar)
if !ok {
return nil, fmt.Errorf("%s not found", MinioEndpointEnvVar)
}
id, ok := os.LookupEnv(Min... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.