_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q177600 | NewAmazonClientFromSecret | test | func NewAmazonClientFromSecret(bucket string, reversed ...bool) (Client, error) {
// Get AWS region (required for constructing an AWS client)
region, err := readSecretFile("/amazon-region")
if err != nil {
return nil, fmt.Errorf("amazon-region not found")
}
// Use or retrieve S3 bucket
if bucket == "" {
buck... | go | {
"resource": ""
} |
q177601 | NewAmazonClientFromEnv | test | func NewAmazonClientFromEnv() (Client, error) {
region, ok := os.LookupEnv(AmazonRegionEnvVar)
if !ok {
return nil, fmt.Errorf("%s not found", AmazonRegionEnvVar)
}
bucket, ok := os.LookupEnv(AmazonBucketEnvVar)
if !ok {
return nil, fmt.Errorf("%s not found", AmazonBucketEnvVar)
}
var creds AmazonCreds
cre... | go | {
"resource": ""
} |
q177602 | NewClientFromURLAndSecret | test | func NewClientFromURLAndSecret(url *ObjectStoreURL, reversed ...bool) (c Client, err error) {
switch url.Store {
case "s3":
c, err = NewAmazonClientFromSecret(url.Bucket, reversed...)
case "gcs":
fallthrough
case "gs":
c, err = NewGoogleClientFromSecret(url.Bucket)
case "as":
fallthrough
case "wasb":
//... | go | {
"resource": ""
} |
q177603 | ParseURL | test | func ParseURL(urlStr string) (*ObjectStoreURL, error) {
url, err := url.Parse(urlStr)
if err != nil {
return nil, fmt.Errorf("error parsing url %v: %v", urlStr, err)
}
switch url.Scheme {
case "s3", "gcs", "gs", "local":
return &ObjectStoreURL{
Store: url.Scheme,
Bucket: url.Host,
Object: strings.Tri... | go | {
"resource": ""
} |
q177604 | NewClientFromEnv | test | func NewClientFromEnv(storageRoot string) (c Client, err error) {
storageBackend, ok := os.LookupEnv(StorageBackendEnvVar)
if !ok {
return nil, fmt.Errorf("storage backend environment variable not found")
}
switch storageBackend {
case Amazon:
c, err = NewAmazonClientFromEnv()
case Google:
c, err = NewGoogl... | go | {
"resource": ""
} |
q177605 | NewExponentialBackOffConfig | test | func NewExponentialBackOffConfig() *backoff.ExponentialBackOff {
config := backoff.NewExponentialBackOff()
// We want to backoff more aggressively (i.e. wait longer) than the default
config.InitialInterval = 1 * time.Second
config.Multiplier = 2
config.MaxInterval = 15 * time.Minute
return config
} | go | {
"resource": ""
} |
q177606 | Close | test | func (b *BackoffReadCloser) Close() error {
span, _ := tracing.AddSpanToAnyExisting(b.ctx, "obj/BackoffReadCloser.Close")
defer tracing.FinishAnySpan(span)
return b.reader.Close()
} | go | {
"resource": ""
} |
q177607 | Close | test | func (b *BackoffWriteCloser) Close() error {
span, _ := tracing.AddSpanToAnyExisting(b.ctx, "obj/BackoffWriteCloser.Close")
defer tracing.FinishAnySpan(span)
err := b.writer.Close()
if b.client.IsIgnorable(err) {
return nil
}
return err
} | go | {
"resource": ""
} |
q177608 | IsRetryable | test | func IsRetryable(client Client, err error) bool {
return isNetRetryable(err) || client.IsRetryable(err)
} | go | {
"resource": ""
} |
q177609 | RunStdin | test | func RunStdin(stdin io.Reader, args ...string) error {
return RunIO(IO{Stdin: stdin}, args...)
} | go | {
"resource": ""
} |
q177610 | RunIODirPath | test | func RunIODirPath(ioObj IO, dirPath string, args ...string) error {
var debugStderr io.ReadWriter = bytes.NewBuffer(nil)
var stderr io.Writer = debugStderr
if ioObj.Stderr != nil {
stderr = io.MultiWriter(debugStderr, ioObj.Stderr)
}
cmd := exec.Command(args[0], args[1:]...)
cmd.Stdin = ioObj.Stdin
cmd.Stdout ... | go | {
"resource": ""
} |
q177611 | NewAuthServer | test | func NewAuthServer(env *serviceenv.ServiceEnv, etcdPrefix string, public bool) (authclient.APIServer, error) {
s := &apiServer{
env: env,
pachLogger: log.NewLogger("authclient.API"),
adminCache: make(map[string]struct{}),
tokens: col.NewCollection(
env.GetEtcdClient(),
path.Join(etcdPrefix, tokens... | go | {
"resource": ""
} |
q177612 | expiredClusterAdminCheck | test | func (a *apiServer) expiredClusterAdminCheck(ctx context.Context, username string) error {
state, err := a.getEnterpriseTokenState()
if err != nil {
return fmt.Errorf("error confirming Pachyderm Enterprise token: %v", err)
}
isAdmin, err := a.isAdmin(ctx, username)
if err != nil {
return err
}
if state != e... | go | {
"resource": ""
} |
q177613 | getOneTimePassword | test | func (a *apiServer) getOneTimePassword(ctx context.Context, username string, expiration time.Time) (code string, err error) {
// Create OTPInfo that will be stored
otpInfo := &authclient.OTPInfo{
Subject: username,
}
if !expiration.IsZero() {
expirationProto, err := types.TimestampProto(expiration)
if err != ... | go | {
"resource": ""
} |
q177614 | hashToken | test | func hashToken(token string) string {
sum := sha256.Sum256([]byte(token))
return fmt.Sprintf("%x", sum)
} | go | {
"resource": ""
} |
q177615 | getAuthToken | test | func getAuthToken(ctx context.Context) (string, error) {
md, ok := metadata.FromIncomingContext(ctx)
if !ok {
return "", authclient.ErrNoMetadata
}
if len(md[authclient.ContextTokenKey]) > 1 {
return "", fmt.Errorf("multiple authentication token keys found in context")
} else if len(md[authclient.ContextTokenK... | go | {
"resource": ""
} |
q177616 | canonicalizeSubjects | test | func (a *apiServer) canonicalizeSubjects(ctx context.Context, subjects []string) ([]string, error) {
if subjects == nil {
return []string{}, nil
}
eg := &errgroup.Group{}
canonicalizedSubjects := make([]string, len(subjects))
for i, subject := range subjects {
i, subject := i, subject
eg.Go(func() error {
... | go | {
"resource": ""
} |
q177617 | Matches | test | func Matches(tb testing.TB, expectedMatch string, actual string, msgAndArgs ...interface{}) {
tb.Helper()
r, err := regexp.Compile(expectedMatch)
if err != nil {
fatal(tb, msgAndArgs, "Match string provided (%v) is invalid", expectedMatch)
}
if !r.MatchString(actual) {
fatal(tb, msgAndArgs, "Actual string (%v)... | go | {
"resource": ""
} |
q177618 | OneOfMatches | test | func OneOfMatches(tb testing.TB, expectedMatch string, actuals []string, msgAndArgs ...interface{}) {
tb.Helper()
r, err := regexp.Compile(expectedMatch)
if err != nil {
fatal(tb, msgAndArgs, "Match string provided (%v) is invalid", expectedMatch)
}
for _, actual := range actuals {
if r.MatchString(actual) {
... | go | {
"resource": ""
} |
q177619 | Equal | test | func Equal(tb testing.TB, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
tb.Helper()
eV, aV := reflect.ValueOf(expected), reflect.ValueOf(actual)
if eV.Type() != aV.Type() {
fatal(
tb,
msgAndArgs,
"Not equal: %T(%#v) (expected)\n"+
" != %T(%#v) (actual)", expected, expec... | go | {
"resource": ""
} |
q177620 | NotEqual | test | func NotEqual(tb testing.TB, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
tb.Helper()
if reflect.DeepEqual(expected, actual) {
fatal(
tb,
msgAndArgs,
"Equal: %#v (expected)\n"+
" == %#v (actual)", expected, actual)
}
} | go | {
"resource": ""
} |
q177621 | oneOfEquals | test | func oneOfEquals(sliceName string, slice interface{}, elem interface{}) (bool, error) {
e := reflect.ValueOf(elem)
sl := reflect.ValueOf(slice)
if slice == nil || sl.IsNil() {
sl = reflect.MakeSlice(reflect.SliceOf(e.Type()), 0, 0)
}
if sl.Kind() != reflect.Slice {
return false, fmt.Errorf("\"%s\" must a be a ... | go | {
"resource": ""
} |
q177622 | NoneEquals | test | func NoneEquals(tb testing.TB, expected interface{}, actuals interface{}, msgAndArgs ...interface{}) {
tb.Helper()
equal, err := oneOfEquals("actuals", actuals, expected)
if err != nil {
fatal(tb, msgAndArgs, err.Error())
}
if equal {
fatal(tb, msgAndArgs,
"Equal : %#v (expected)\n == one of %#v (actuals)",... | go | {
"resource": ""
} |
q177623 | NoError | test | func NoError(tb testing.TB, err error, msgAndArgs ...interface{}) {
tb.Helper()
if err != nil {
fatal(tb, msgAndArgs, "No error is expected but got %s", err.Error())
}
} | go | {
"resource": ""
} |
q177624 | NoErrorWithinT | test | func NoErrorWithinT(tb testing.TB, t time.Duration, f func() error, msgAndArgs ...interface{}) {
tb.Helper()
errCh := make(chan error)
go func() {
// This goro will leak if the timeout is exceeded, but it's okay because the
// test is failing anyway
errCh <- f()
}()
select {
case err := <-errCh:
if err !=... | go | {
"resource": ""
} |
q177625 | NoErrorWithinTRetry | test | func NoErrorWithinTRetry(tb testing.TB, t time.Duration, f func() error, msgAndArgs ...interface{}) {
tb.Helper()
doneCh := make(chan struct{})
timeout := false
var err error
go func() {
for !timeout {
if err = f(); err == nil {
close(doneCh)
break
}
}
}()
select {
case <-doneCh:
case <-time.... | go | {
"resource": ""
} |
q177626 | YesError | test | func YesError(tb testing.TB, err error, msgAndArgs ...interface{}) {
tb.Helper()
if err == nil {
fatal(tb, msgAndArgs, "Error is expected but got %v", err)
}
} | go | {
"resource": ""
} |
q177627 | NotNil | test | func NotNil(tb testing.TB, object interface{}, msgAndArgs ...interface{}) {
tb.Helper()
success := true
if object == nil {
success = false
} else {
value := reflect.ValueOf(object)
kind := value.Kind()
if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() {
success = false
}
}
if !succe... | go | {
"resource": ""
} |
q177628 | Nil | test | func Nil(tb testing.TB, object interface{}, msgAndArgs ...interface{}) {
tb.Helper()
if object == nil {
return
}
value := reflect.ValueOf(object)
kind := value.Kind()
if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() {
return
}
fatal(tb, msgAndArgs, "Expected value to be nil, but was %v", o... | go | {
"resource": ""
} |
q177629 | False | test | func False(tb testing.TB, value bool, msgAndArgs ...interface{}) {
tb.Helper()
if value {
fatal(tb, msgAndArgs, "Should be false.")
}
} | go | {
"resource": ""
} |
q177630 | NewSTM | test | func NewSTM(ctx context.Context, c *v3.Client, apply func(STM) error) (*v3.TxnResponse, error) {
return newSTMSerializable(ctx, c, apply, false)
} | go | {
"resource": ""
} |
q177631 | NewDryrunSTM | test | func NewDryrunSTM(ctx context.Context, c *v3.Client, apply func(STM) error) error {
_, err := newSTMSerializable(ctx, c, apply, true)
return err
} | go | {
"resource": ""
} |
q177632 | newSTMRepeatable | test | func newSTMRepeatable(ctx context.Context, c *v3.Client, apply func(STM) error) (*v3.TxnResponse, error) {
s := &stm{client: c, ctx: ctx, getOpts: []v3.OpOption{v3.WithSerializable()}}
return runSTM(s, apply, false)
} | go | {
"resource": ""
} |
q177633 | newSTMSerializable | test | func newSTMSerializable(ctx context.Context, c *v3.Client, apply func(STM) error, dryrun bool) (*v3.TxnResponse, error) {
s := &stmSerializable{
stm: stm{client: c, ctx: ctx},
prefetch: make(map[string]*v3.GetResponse),
}
return runSTM(s, apply, dryrun)
} | go | {
"resource": ""
} |
q177634 | newSTMReadCommitted | test | func newSTMReadCommitted(ctx context.Context, c *v3.Client, apply func(STM) error) (*v3.TxnResponse, error) {
s := &stmReadCommitted{stm{client: c, ctx: ctx, getOpts: []v3.OpOption{v3.WithSerializable()}}}
return runSTM(s, apply, true)
} | go | {
"resource": ""
} |
q177635 | commit | test | func (s *stmReadCommitted) commit() *v3.TxnResponse {
s.rset = nil
return s.stm.commit()
} | go | {
"resource": ""
} |
q177636 | Pipelines | test | func Pipelines(etcdClient *etcd.Client, etcdPrefix string) col.Collection {
return col.NewCollection(
etcdClient,
path.Join(etcdPrefix, pipelinesPrefix),
nil,
&pps.EtcdPipelineInfo{},
nil,
nil,
)
} | go | {
"resource": ""
} |
q177637 | Jobs | test | func Jobs(etcdClient *etcd.Client, etcdPrefix string) col.Collection {
return col.NewCollection(
etcdClient,
path.Join(etcdPrefix, jobsPrefix),
[]*col.Index{JobsPipelineIndex, JobsOutputIndex},
&pps.EtcdJobInfo{},
nil,
nil,
)
} | go | {
"resource": ""
} |
q177638 | NewTicker | test | func NewTicker(b BackOff) *Ticker {
c := make(chan time.Time)
t := &Ticker{
C: c,
c: c,
b: b,
stop: make(chan struct{}),
}
go t.run()
runtime.SetFinalizer(t, (*Ticker).Stop)
return t
} | go | {
"resource": ""
} |
q177639 | nodeToMap | test | func nodeToMap(node *etcd.Node, out map[string]string) bool {
key := strings.TrimPrefix(node.Key, "/")
if !node.Dir {
if node.Value == "" {
if _, ok := out[key]; ok {
delete(out, key)
return true
}
return false
}
if value, ok := out[key]; !ok || value != node.Value {
out[key] = node.Value
... | go | {
"resource": ""
} |
q177640 | ServiceAccount | test | func ServiceAccount(opts *AssetOpts) *v1.ServiceAccount {
return &v1.ServiceAccount{
TypeMeta: metav1.TypeMeta{
Kind: "ServiceAccount",
APIVersion: "v1",
},
ObjectMeta: objectMeta(ServiceAccountName, labels(""), nil, opts.Namespace),
}
} | go | {
"resource": ""
} |
q177641 | ClusterRole | test | func ClusterRole(opts *AssetOpts) *rbacv1.ClusterRole {
return &rbacv1.ClusterRole{
TypeMeta: metav1.TypeMeta{
Kind: "ClusterRole",
APIVersion: "rbac.authorization.k8s.io/v1",
},
ObjectMeta: objectMeta(roleName, labels(""), nil, opts.Namespace),
Rules: rolePolicyRules,
}
} | go | {
"resource": ""
} |
q177642 | RoleBinding | test | func RoleBinding(opts *AssetOpts) *rbacv1.RoleBinding {
return &rbacv1.RoleBinding{
TypeMeta: metav1.TypeMeta{
Kind: "RoleBinding",
APIVersion: "rbac.authorization.k8s.io/v1",
},
ObjectMeta: objectMeta(roleBindingName, labels(""), nil, opts.Namespace),
Subjects: []rbacv1.Subject{{
Kind: "Se... | go | {
"resource": ""
} |
q177643 | GetSecretEnvVars | test | func GetSecretEnvVars(storageBackend string) []v1.EnvVar {
var envVars []v1.EnvVar
if storageBackend != "" {
envVars = append(envVars, v1.EnvVar{
Name: obj.StorageBackendEnvVar,
Value: storageBackend,
})
}
trueVal := true
for envVar, secretKey := range obj.EnvVarToSecretKey {
envVars = append(envVars,... | go | {
"resource": ""
} |
q177644 | PachdService | test | func PachdService(opts *AssetOpts) *v1.Service {
prometheusAnnotations := map[string]string{
"prometheus.io/scrape": "true",
"prometheus.io/port": strconv.Itoa(PrometheusPort),
}
return &v1.Service{
TypeMeta: metav1.TypeMeta{
Kind: "Service",
APIVersion: "v1",
},
ObjectMeta: objectMeta(pachdN... | go | {
"resource": ""
} |
q177645 | GithookService | test | func GithookService(namespace string) *v1.Service {
name := "githook"
return &v1.Service{
TypeMeta: metav1.TypeMeta{
Kind: "Service",
APIVersion: "v1",
},
ObjectMeta: objectMeta(name, labels(name), nil, namespace),
Spec: v1.ServiceSpec{
Type: v1.ServiceTypeLoadBalancer,
Selector: map[string]... | go | {
"resource": ""
} |
q177646 | EtcdDeployment | test | func EtcdDeployment(opts *AssetOpts, hostPath string) *apps.Deployment {
cpu := resource.MustParse(opts.EtcdCPURequest)
mem := resource.MustParse(opts.EtcdMemRequest)
var volumes []v1.Volume
if hostPath == "" {
volumes = []v1.Volume{
{
Name: "etcd-storage",
VolumeSource: v1.VolumeSource{
Persisten... | go | {
"resource": ""
} |
q177647 | EtcdStorageClass | test | func EtcdStorageClass(opts *AssetOpts, backend backend) (interface{}, error) {
sc := map[string]interface{}{
"apiVersion": "storage.k8s.io/v1beta1",
"kind": "StorageClass",
"metadata": map[string]interface{}{
"name": defaultEtcdStorageClassName,
"labels": labels(etcdName),
"namespace": opt... | go | {
"resource": ""
} |
q177648 | EtcdVolume | test | func EtcdVolume(persistentDiskBackend backend, opts *AssetOpts,
hostPath string, name string, size int) (*v1.PersistentVolume, error) {
spec := &v1.PersistentVolume{
TypeMeta: metav1.TypeMeta{
Kind: "PersistentVolume",
APIVersion: "v1",
},
ObjectMeta: objectMeta(etcdVolumeName, labels(etcdName), nil... | go | {
"resource": ""
} |
q177649 | EtcdNodePortService | test | func EtcdNodePortService(local bool, opts *AssetOpts) *v1.Service {
var clientNodePort int32
if local {
clientNodePort = 32379
}
return &v1.Service{
TypeMeta: metav1.TypeMeta{
Kind: "Service",
APIVersion: "v1",
},
ObjectMeta: objectMeta(etcdName, labels(etcdName), nil, opts.Namespace),
Spec: v... | go | {
"resource": ""
} |
q177650 | EtcdHeadlessService | test | func EtcdHeadlessService(opts *AssetOpts) *v1.Service {
return &v1.Service{
TypeMeta: metav1.TypeMeta{
Kind: "Service",
APIVersion: "v1",
},
ObjectMeta: objectMeta(etcdHeadlessServiceName, labels(etcdName), nil, opts.Namespace),
Spec: v1.ServiceSpec{
Selector: map[string]string{
"app": etcdN... | go | {
"resource": ""
} |
q177651 | EtcdStatefulSet | test | func EtcdStatefulSet(opts *AssetOpts, backend backend, diskSpace int) interface{} {
mem := resource.MustParse(opts.EtcdMemRequest)
cpu := resource.MustParse(opts.EtcdCPURequest)
initialCluster := make([]string, 0, opts.EtcdNodes)
for i := 0; i < opts.EtcdNodes; i++ {
url := fmt.Sprintf("http://etcd-%d.etcd-headle... | go | {
"resource": ""
} |
q177652 | DashDeployment | test | func DashDeployment(opts *AssetOpts) *apps.Deployment {
return &apps.Deployment{
TypeMeta: metav1.TypeMeta{
Kind: "Deployment",
APIVersion: "apps/v1beta1",
},
ObjectMeta: objectMeta(dashName, labels(dashName), nil, opts.Namespace),
Spec: apps.DeploymentSpec{
Selector: &metav1.LabelSelector{
... | go | {
"resource": ""
} |
q177653 | DashService | test | func DashService(opts *AssetOpts) *v1.Service {
return &v1.Service{
TypeMeta: metav1.TypeMeta{
Kind: "Service",
APIVersion: "v1",
},
ObjectMeta: objectMeta(dashName, labels(dashName), nil, opts.Namespace),
Spec: v1.ServiceSpec{
Type: v1.ServiceTypeNodePort,
Selector: labels(dashName),
... | go | {
"resource": ""
} |
q177654 | WriteSecret | test | func WriteSecret(encoder Encoder, data map[string][]byte, opts *AssetOpts) error {
if opts.DashOnly {
return nil
}
secret := &v1.Secret{
TypeMeta: metav1.TypeMeta{
Kind: "Secret",
APIVersion: "v1",
},
ObjectMeta: objectMeta(client.StorageSecretName, labels(client.StorageSecretName), nil, opts.Nam... | go | {
"resource": ""
} |
q177655 | GoogleSecret | test | func GoogleSecret(bucket string, cred string) map[string][]byte {
return map[string][]byte{
"google-bucket": []byte(bucket),
"google-cred": []byte(cred),
}
} | go | {
"resource": ""
} |
q177656 | WriteDashboardAssets | test | func WriteDashboardAssets(encoder Encoder, opts *AssetOpts) error {
if err := encoder.Encode(DashService(opts)); err != nil {
return err
}
return encoder.Encode(DashDeployment(opts))
} | go | {
"resource": ""
} |
q177657 | WriteLocalAssets | test | func WriteLocalAssets(encoder Encoder, opts *AssetOpts, hostPath string) error {
if err := WriteAssets(encoder, opts, localBackend, localBackend, 1 /* = volume size (gb) */, hostPath); err != nil {
return err
}
if secretErr := WriteSecret(encoder, LocalSecret(), opts); secretErr != nil {
return secretErr
}
ret... | go | {
"resource": ""
} |
q177658 | WriteCustomAssets | test | func WriteCustomAssets(encoder Encoder, opts *AssetOpts, args []string, objectStoreBackend string,
persistentDiskBackend string, secure, isS3V2 bool) error {
switch objectStoreBackend {
case "s3":
if len(args) != s3CustomArgs {
return fmt.Errorf("Expected %d arguments for disk+s3 backend", s3CustomArgs)
}
v... | go | {
"resource": ""
} |
q177659 | WriteAmazonAssets | test | func WriteAmazonAssets(encoder Encoder, opts *AssetOpts, region string, bucket string, volumeSize int, creds *AmazonCreds, cloudfrontDistro string) error {
if err := WriteAssets(encoder, opts, amazonBackend, amazonBackend, volumeSize, ""); err != nil {
return err
}
var secret map[string][]byte
if creds == nil {
... | go | {
"resource": ""
} |
q177660 | WriteGoogleAssets | test | func WriteGoogleAssets(encoder Encoder, opts *AssetOpts, bucket string, cred string, volumeSize int) error {
if err := WriteAssets(encoder, opts, googleBackend, googleBackend, volumeSize, ""); err != nil {
return err
}
return WriteSecret(encoder, GoogleSecret(bucket, cred), opts)
} | go | {
"resource": ""
} |
q177661 | WriteMicrosoftAssets | test | func WriteMicrosoftAssets(encoder Encoder, opts *AssetOpts, container string, id string, secret string, volumeSize int) error {
if err := WriteAssets(encoder, opts, microsoftBackend, microsoftBackend, volumeSize, ""); err != nil {
return err
}
return WriteSecret(encoder, MicrosoftSecret(container, id, secret), opt... | go | {
"resource": ""
} |
q177662 | Images | test | func Images(opts *AssetOpts) []string {
return []string{
versionedWorkerImage(opts),
etcdImage,
grpcProxyImage,
pauseImage,
versionedPachdImage(opts),
opts.DashImage,
}
} | go | {
"resource": ""
} |
q177663 | AddRegistry | test | func AddRegistry(registry string, imageName string) string {
if registry == "" {
return imageName
}
parts := strings.Split(imageName, "/")
if len(parts) == 3 {
parts = parts[1:]
}
return path.Join(registry, parts[0], parts[1])
} | go | {
"resource": ""
} |
q177664 | withCanonicalRandomizationFactor | test | func (b *ExponentialBackOff) withCanonicalRandomizationFactor() *ExponentialBackOff {
if b.RandomizationFactor < 0 {
b.RandomizationFactor = 0
} else if b.RandomizationFactor > 1 {
b.RandomizationFactor = 1
}
return b
} | go | {
"resource": ""
} |
q177665 | Reset | test | func (b *ExponentialBackOff) Reset() {
b.currentInterval = b.InitialInterval
b.startTime = b.Clock.Now()
} | go | {
"resource": ""
} |
q177666 | incrementCurrentInterval | test | func (b *ExponentialBackOff) incrementCurrentInterval() {
// Check for overflow, if overflow is detected set the current interval to the max interval.
if float64(b.currentInterval) >= float64(b.MaxInterval)/b.Multiplier {
b.currentInterval = b.MaxInterval
} else {
b.currentInterval = time.Duration(float64(b.curr... | go | {
"resource": ""
} |
q177667 | NewBlockAPIServer | test | func NewBlockAPIServer(dir string, cacheBytes int64, backend string, etcdAddress string) (BlockAPIServer, error) {
switch backend {
case MinioBackendEnvVar:
// S3 compatible doesn't like leading slashes
if len(dir) > 0 && dir[0] == '/' {
dir = dir[1:]
}
blockAPIServer, err := newMinioBlockAPIServer(dir, ca... | go | {
"resource": ""
} |
q177668 | LocalStorage | test | func LocalStorage(tb testing.TB) (obj.Client, *Storage) {
wd, err := os.Getwd()
require.NoError(tb, err)
objC, err := obj.NewLocalClient(wd)
require.NoError(tb, err)
return objC, NewStorage(objC, Prefix)
} | go | {
"resource": ""
} |
q177669 | deleteJob | test | func (a *APIServer) deleteJob(stm col.STM, jobPtr *pps.EtcdJobInfo) error {
pipelinePtr := &pps.EtcdPipelineInfo{}
if err := a.pipelines.ReadWrite(stm).Update(jobPtr.Pipeline.Name, pipelinePtr, func() error {
if pipelinePtr.JobCounts == nil {
pipelinePtr.JobCounts = make(map[int32]int32)
}
if pipelinePtr.Job... | go | {
"resource": ""
} |
q177670 | writeXML | test | func writeXML(w http.ResponseWriter, r *http.Request, code int, v interface{}) {
w.Header().Set("Content-Type", "application/xml")
w.WriteHeader(code)
encoder := xml.NewEncoder(w)
if err := encoder.Encode(v); err != nil {
// just log a message since a response has already been partially
// written
requestLogg... | go | {
"resource": ""
} |
q177671 | clean1_7HashtreePath | test | func clean1_7HashtreePath(p string) string {
if !strings.HasPrefix(p, "/") {
p = "/" + p
}
return default1_7HashtreeRoot(pathlib.Clean(p))
} | go | {
"resource": ""
} |
q177672 | NewFromAddress | test | func NewFromAddress(addr string, options ...Option) (*APIClient, error) {
// Apply creation options
settings := clientSettings{
maxConcurrentStreams: DefaultMaxConcurrentStreams,
dialTimeout: DefaultDialTimeout,
}
for _, option := range options {
if err := option(&settings); err != nil {
return ni... | go | {
"resource": ""
} |
q177673 | getUserMachineAddrAndOpts | test | func getUserMachineAddrAndOpts(cfg *config.Config) (string, []Option, error) {
// 1) PACHD_ADDRESS environment variable (shell-local) overrides global config
if envAddr, ok := os.LookupEnv("PACHD_ADDRESS"); ok {
if !strings.Contains(envAddr, ":") {
envAddr = fmt.Sprintf("%s:%s", envAddr, DefaultPachdNodePort)
... | go | {
"resource": ""
} |
q177674 | NewInCluster | test | func NewInCluster(options ...Option) (*APIClient, error) {
host, ok := os.LookupEnv("PACHD_SERVICE_HOST")
if !ok {
return nil, fmt.Errorf("PACHD_SERVICE_HOST not set")
}
port, ok := os.LookupEnv("PACHD_SERVICE_PORT")
if !ok {
return nil, fmt.Errorf("PACHD_SERVICE_PORT not set")
}
// create new pachctl client... | go | {
"resource": ""
} |
q177675 | Close | test | func (c *APIClient) Close() error {
if err := c.clientConn.Close(); err != nil {
return err
}
if c.portForwarder != nil {
c.portForwarder.Close()
}
return nil
} | go | {
"resource": ""
} |
q177676 | DeleteAll | test | func (c APIClient) DeleteAll() error {
if _, err := c.AuthAPIClient.Deactivate(
c.Ctx(),
&auth.DeactivateRequest{},
); err != nil && !auth.IsErrNotActivated(err) {
return grpcutil.ScrubGRPC(err)
}
if _, err := c.PpsAPIClient.DeleteAll(
c.Ctx(),
&types.Empty{},
); err != nil {
return grpcutil.ScrubGRPC(... | go | {
"resource": ""
} |
q177677 | SetMaxConcurrentStreams | test | func (c APIClient) SetMaxConcurrentStreams(n int) {
c.limiter = limit.New(n)
} | go | {
"resource": ""
} |
q177678 | WithCtx | test | func (c *APIClient) WithCtx(ctx context.Context) *APIClient {
result := *c // copy c
result.ctx = ctx
return &result
} | go | {
"resource": ""
} |
q177679 | NewDLock | test | func NewDLock(client *etcd.Client, prefix string) DLock {
return &etcdImpl{
client: client,
prefix: prefix,
}
} | go | {
"resource": ""
} |
q177680 | DatumID | test | func (a *APIServer) DatumID(data []*Input) string {
hash := sha256.New()
for _, d := range data {
hash.Write([]byte(d.FileInfo.File.Path))
hash.Write(d.FileInfo.Hash)
}
// InputFileID is a single string id for the data from this input, it's used in logs and in
// the statsTree
return hex.EncodeToString(hash.S... | go | {
"resource": ""
} |
q177681 | runUserErrorHandlingCode | test | func (a *APIServer) runUserErrorHandlingCode(ctx context.Context, logger *taggedLogger, environ []string, stats *pps.ProcessStats, rawDatumTimeout *types.Duration) (retErr error) {
logger.Logf("beginning to run user error handling code")
defer func(start time.Time) {
if retErr != nil {
logger.Logf("errored runni... | go | {
"resource": ""
} |
q177682 | HashDatum | test | func HashDatum(pipelineName string, pipelineSalt string, data []*Input) string {
hash := sha256.New()
for _, datum := range data {
hash.Write([]byte(datum.Name))
hash.Write([]byte(datum.FileInfo.File.Path))
hash.Write(datum.FileInfo.Hash)
}
hash.Write([]byte(pipelineName))
hash.Write([]byte(pipelineSalt))
... | go | {
"resource": ""
} |
q177683 | HashDatum15 | test | func HashDatum15(pipelineInfo *pps.PipelineInfo, data []*Input) (string, error) {
hash := sha256.New()
for _, datum := range data {
hash.Write([]byte(datum.Name))
hash.Write([]byte(datum.FileInfo.File.Path))
hash.Write(datum.FileInfo.Hash)
}
// We set env to nil because if env contains more than one elements... | go | {
"resource": ""
} |
q177684 | Status | test | func (a *APIServer) Status(ctx context.Context, _ *types.Empty) (*pps.WorkerStatus, error) {
a.statusMu.Lock()
defer a.statusMu.Unlock()
started, err := types.TimestampProto(a.started)
if err != nil {
return nil, err
}
result := &pps.WorkerStatus{
JobID: a.jobID,
WorkerID: a.workerName,
Started: st... | go | {
"resource": ""
} |
q177685 | Cancel | test | func (a *APIServer) Cancel(ctx context.Context, request *CancelRequest) (*CancelResponse, error) {
a.statusMu.Lock()
defer a.statusMu.Unlock()
if request.JobID != a.jobID {
return &CancelResponse{Success: false}, nil
}
if !MatchDatum(request.DataFilters, a.datum()) {
return &CancelResponse{Success: false}, nil... | go | {
"resource": ""
} |
q177686 | mergeStats | test | func mergeStats(x, y *pps.ProcessStats) error {
var err error
if x.DownloadTime, err = plusDuration(x.DownloadTime, y.DownloadTime); err != nil {
return err
}
if x.ProcessTime, err = plusDuration(x.ProcessTime, y.ProcessTime); err != nil {
return err
}
if x.UploadTime, err = plusDuration(x.UploadTime, y.Uploa... | go | {
"resource": ""
} |
q177687 | mergeChunk | test | func (a *APIServer) mergeChunk(logger *taggedLogger, high int64, result *processResult) (retErr error) {
logger.Logf("starting to merge chunk")
defer func(start time.Time) {
if retErr != nil {
logger.Logf("errored merging chunk after %v: %v", time.Since(start), retErr)
} else {
logger.Logf("finished merging... | go | {
"resource": ""
} |
q177688 | IsCommitNotFoundErr | test | func IsCommitNotFoundErr(err error) bool {
if err == nil {
return false
}
return commitNotFoundRe.MatchString(grpcutil.ScrubGRPC(err).Error())
} | go | {
"resource": ""
} |
q177689 | IsCommitDeletedErr | test | func IsCommitDeletedErr(err error) bool {
if err == nil {
return false
}
return commitDeletedRe.MatchString(grpcutil.ScrubGRPC(err).Error())
} | go | {
"resource": ""
} |
q177690 | IsCommitFinishedErr | test | func IsCommitFinishedErr(err error) bool {
if err == nil {
return false
}
return commitFinishedRe.MatchString(grpcutil.ScrubGRPC(err).Error())
} | go | {
"resource": ""
} |
q177691 | IsRepoNotFoundErr | test | func IsRepoNotFoundErr(err error) bool {
if err == nil {
return false
}
return repoNotFoundRe.MatchString(err.Error())
} | go | {
"resource": ""
} |
q177692 | IsBranchNotFoundErr | test | func IsBranchNotFoundErr(err error) bool {
if err == nil {
return false
}
return branchNotFoundRe.MatchString(err.Error())
} | go | {
"resource": ""
} |
q177693 | IsFileNotFoundErr | test | func IsFileNotFoundErr(err error) bool {
if err == nil {
return false
}
return fileNotFoundRe.MatchString(err.Error())
} | go | {
"resource": ""
} |
q177694 | Version | test | func (c APIClient) Version() (string, error) {
v, err := c.VersionAPIClient.GetVersion(c.Ctx(), &types.Empty{})
if err != nil {
return "", grpcutil.ScrubGRPC(err)
}
return version.PrettyPrintVersion(v), nil
} | go | {
"resource": ""
} |
q177695 | validateRepoName | test | func validateRepoName(name string) error {
match, _ := regexp.MatchString("^[a-zA-Z0-9_-]+$", name)
if !match {
return fmt.Errorf("repo name (%v) invalid: only alphanumeric characters, underscores, and dashes are allowed", name)
}
return nil
} | go | {
"resource": ""
} |
q177696 | newDriver | test | func newDriver(env *serviceenv.ServiceEnv, etcdPrefix string, treeCache *hashtree.Cache, storageRoot string, memoryRequest int64) (*driver, error) {
// Validate arguments
if treeCache == nil {
return nil, fmt.Errorf("cannot initialize driver with nil treeCache")
}
// Initialize driver
etcdClient := env.GetEtcdCl... | go | {
"resource": ""
} |
q177697 | inspectCommit | test | func (d *driver) inspectCommit(pachClient *client.APIClient, commit *pfs.Commit, blockState pfs.CommitState) (*pfs.CommitInfo, error) {
ctx := pachClient.Ctx()
if commit == nil {
return nil, fmt.Errorf("cannot inspect nil commit")
}
if err := d.checkIsAuthorized(pachClient, commit.Repo, auth.Scope_READER); err !=... | go | {
"resource": ""
} |
q177698 | scratchCommitPrefix | test | func (d *driver) scratchCommitPrefix(commit *pfs.Commit) string {
// TODO(msteffen) this doesn't currenty (2018-2-4) use d.scratchPrefix(),
// but probably should? If this is changed, filepathFromEtcdPath will also
// need to change.
return path.Join(commit.Repo.Name, commit.ID)
} | go | {
"resource": ""
} |
q177699 | scratchFilePrefix | test | func (d *driver) scratchFilePrefix(file *pfs.File) (string, error) {
return path.Join(d.scratchCommitPrefix(file.Commit), file.Path), nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.