_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q177700 | getTreeForFile | test | func (d *driver) getTreeForFile(pachClient *client.APIClient, file *pfs.File) (hashtree.HashTree, error) {
if file.Commit == nil {
t, err := hashtree.NewDBHashTree(d.storageRoot)
if err != nil {
return nil, err
}
return t, nil
}
commitInfo, err := d.inspectCommit(pachClient, file.Commit, pfs.CommitState_S... | go | {
"resource": ""
} |
q177701 | provenantOnInput | test | func provenantOnInput(provenance []*pfs.CommitProvenance) bool {
provenanceCount := len(provenance)
for _, p := range provenance {
// in particular, we want to exclude provenance on the spec repo (used e.g. for spouts)
if p.Commit.Repo.Name == ppsconsts.SpecRepo {
provenanceCount--
break
}
}
return prov... | go | {
"resource": ""
} |
q177702 | nodeToFileInfo | test | func nodeToFileInfo(ci *pfs.CommitInfo, path string, node *hashtree.NodeProto, full bool) *pfs.FileInfo {
fileInfo := &pfs.FileInfo{
File: &pfs.File{
Commit: ci.Commit,
Path: path,
},
SizeBytes: uint64(node.SubtreeSize),
Hash: node.Hash,
Committed: ci.Finished,
}
if node.FileNode != nil {
fi... | go | {
"resource": ""
} |
q177703 | fileHistory | test | func (d *driver) fileHistory(pachClient *client.APIClient, file *pfs.File, history int64, f func(*pfs.FileInfo) error) error {
var fi *pfs.FileInfo
for {
_fi, err := d.inspectFile(pachClient, file)
if err != nil {
if _, ok := err.(pfsserver.ErrFileNotFound); ok {
return f(fi)
}
return err
}
if fi... | go | {
"resource": ""
} |
q177704 | upsertPutFileRecords | test | func (d *driver) upsertPutFileRecords(pachClient *client.APIClient, file *pfs.File, newRecords *pfs.PutFileRecords) error {
prefix, err := d.scratchFilePrefix(file)
if err != nil {
return err
}
ctx := pachClient.Ctx()
_, err = col.NewSTM(ctx, d.etcdClient, func(stm col.STM) error {
commitsCol := d.openCommits... | go | {
"resource": ""
} |
q177705 | ReadRow | test | func (r *PGDumpReader) ReadRow() ([]byte, error) {
if len(r.Header) == 0 {
err := r.readHeader()
if err != nil {
return nil, err
}
}
endLine := "\\.\n" // Trailing '\.' denotes the end of the row inserts
row, err := r.rd.ReadBytes('\n')
if err != nil && err != io.EOF {
return nil, fmt.Errorf("error read... | go | {
"resource": ""
} |
q177706 | NewReporter | test | func NewReporter(clusterID string, kubeClient *kube.Clientset) *Reporter {
reporter := &Reporter{
segmentClient: newPersistentClient(),
clusterID: clusterID,
kubeClient: kubeClient,
}
go reporter.reportClusterMetrics()
return reporter
} | go | {
"resource": ""
} |
q177707 | ReportUserAction | test | func ReportUserAction(ctx context.Context, r *Reporter, action string) func(time.Time, error) {
if r == nil {
// This happens when stubbing out metrics for testing, e.g. src/server/pfs/server/server_test.go
return func(time.Time, error) {}
}
// If we report nil, segment sees it, but mixpanel omits the field
r.r... | go | {
"resource": ""
} |
q177708 | FinishReportAndFlushUserAction | test | func FinishReportAndFlushUserAction(action string, err error, start time.Time) func() {
var wait func()
if err != nil {
wait = reportAndFlushUserAction(fmt.Sprintf("%vErrored", action), err)
} else {
wait = reportAndFlushUserAction(fmt.Sprintf("%vFinished", action), time.Since(start).Seconds())
}
return wait
} | go | {
"resource": ""
} |
q177709 | Read | test | func (r *Reader) Read(data []byte) (int, error) {
var totalRead int
for len(data) > 0 {
n, err := r.r.Read(data)
data = data[n:]
totalRead += n
if err != nil {
// If all DataRefs have been read, then io.EOF.
if len(r.dataRefs) == 0 {
return totalRead, io.EOF
}
// Get next chunk if necessary.
... | go | {
"resource": ""
} |
q177710 | ActivateCmd | test | func ActivateCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
var expires string
activate := &cobra.Command{
Use: "{{alias}} <activation-code>",
Short: "Activate the enterprise features of Pachyderm with an activation " +
"code",
Long: "Activate the enterprise features of Pachyderm with an activation ... | go | {
"resource": ""
} |
q177711 | GetStateCmd | test | func GetStateCmd(noMetrics, noPortForwarding *bool) *cobra.Command {
getState := &cobra.Command{
Short: "Check whether the Pachyderm cluster has enterprise features " +
"activated",
Long: "Check whether the Pachyderm cluster has enterprise features " +
"activated",
Run: cmdutil.Run(func(args []string) erro... | go | {
"resource": ""
} |
q177712 | Cmds | test | func Cmds(noMetrics, noPortForwarding *bool) []*cobra.Command {
var commands []*cobra.Command
enterprise := &cobra.Command{
Short: "Enterprise commands enable Pachyderm Enterprise features",
Long: "Enterprise commands enable Pachyderm Enterprise features",
}
commands = append(commands, cmdutil.CreateAlias(ent... | go | {
"resource": ""
} |
q177713 | NewConfiguration | test | func NewConfiguration(config interface{}) *Configuration {
configuration := &Configuration{}
switch config.(type) {
case *GlobalConfiguration:
configuration.GlobalConfiguration = config.(*GlobalConfiguration)
return configuration
case *PachdFullConfiguration:
configuration.GlobalConfiguration = &config.(*Pach... | go | {
"resource": ""
} |
q177714 | Repos | test | func Repos(etcdClient *etcd.Client, etcdPrefix string) col.Collection {
return col.NewCollection(
etcdClient,
path.Join(etcdPrefix, reposPrefix),
nil,
&pfs.RepoInfo{},
nil,
nil,
)
} | go | {
"resource": ""
} |
q177715 | PutFileRecords | test | func PutFileRecords(etcdClient *etcd.Client, etcdPrefix string) col.Collection {
return col.NewCollection(
etcdClient,
path.Join(etcdPrefix, putFileRecordsPrefix),
nil,
&pfs.PutFileRecords{},
nil,
nil,
)
} | go | {
"resource": ""
} |
q177716 | Commits | test | func Commits(etcdClient *etcd.Client, etcdPrefix string, repo string) col.Collection {
return col.NewCollection(
etcdClient,
path.Join(etcdPrefix, commitsPrefix, repo),
[]*col.Index{ProvenanceIndex},
&pfs.CommitInfo{},
nil,
nil,
)
} | go | {
"resource": ""
} |
q177717 | Branches | test | func Branches(etcdClient *etcd.Client, etcdPrefix string, repo string) col.Collection {
return col.NewCollection(
etcdClient,
path.Join(etcdPrefix, branchesPrefix, repo),
nil,
&pfs.BranchInfo{},
func(key string) error {
if uuid.IsUUIDWithoutDashes(key) {
return fmt.Errorf("branch name cannot be a UUID... | go | {
"resource": ""
} |
q177718 | OpenCommits | test | func OpenCommits(etcdClient *etcd.Client, etcdPrefix string) col.Collection {
return col.NewCollection(
etcdClient,
path.Join(etcdPrefix, openCommitsPrefix),
nil,
&pfs.Commit{},
nil,
nil,
)
} | go | {
"resource": ""
} |
q177719 | NewDAG | test | func NewDAG(nodes map[string][]string) *DAG {
result := &DAG{
parents: make(map[string][]string),
children: make(map[string][]string),
leaves: make(map[string]bool),
}
for id, parents := range nodes {
result.NewNode(id, parents)
}
return result
} | go | {
"resource": ""
} |
q177720 | NewNode | test | func (d *DAG) NewNode(id string, parents []string) {
d.parents[id] = parents
for _, parentID := range parents {
d.children[parentID] = append(d.children[parentID], id)
d.leaves[parentID] = false
}
if _, ok := d.leaves[id]; !ok {
d.leaves[id] = true
}
} | go | {
"resource": ""
} |
q177721 | Sorted | test | func (d *DAG) Sorted() []string {
seen := make(map[string]bool)
var result []string
for id := range d.parents {
result = append(result, dfs(id, d.parents, seen)...)
}
return result
} | go | {
"resource": ""
} |
q177722 | Leaves | test | func (d *DAG) Leaves() []string {
var result []string
for id, isLeaf := range d.leaves {
// isLeaf might be false, explicit mark nodes as non leaves
if isLeaf {
result = append(result, id)
}
}
return result
} | go | {
"resource": ""
} |
q177723 | Ancestors | test | func (d *DAG) Ancestors(id string, from []string) []string {
seen := make(map[string]bool)
for _, fromID := range from {
seen[fromID] = true
}
return dfs(id, d.parents, seen)
} | go | {
"resource": ""
} |
q177724 | Descendants | test | func (d *DAG) Descendants(id string, to []string) []string {
seen := make(map[string]bool)
for _, toID := range to {
seen[toID] = true
}
return bfs(id, d.children, seen)
} | go | {
"resource": ""
} |
q177725 | Ghosts | test | func (d *DAG) Ghosts() []string {
var result []string
for id := range d.children {
if _, ok := d.parents[id]; !ok {
result = append(result, id)
}
}
return result
} | go | {
"resource": ""
} |
q177726 | NewPortForwarder | test | func NewPortForwarder(namespace string) (*PortForwarder, error) {
if namespace == "" {
namespace = "default"
}
rules := clientcmd.NewDefaultClientConfigLoadingRules()
overrides := &clientcmd.ConfigOverrides{}
kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(rules, overrides)
config, err := ... | go | {
"resource": ""
} |
q177727 | Run | test | func (f *PortForwarder) Run(appName string, localPort, remotePort uint16) error {
podNameSelector := map[string]string{
"suite": "pachyderm",
"app": appName,
}
podList, err := f.core.Pods(f.namespace).List(metav1.ListOptions{
LabelSelector: metav1.FormatLabelSelector(metav1.SetAsLabelSelector(podNameSelecto... | go | {
"resource": ""
} |
q177728 | RunForDaemon | test | func (f *PortForwarder) RunForDaemon(localPort, remotePort uint16) error {
if localPort == 0 {
localPort = pachdLocalPort
}
if remotePort == 0 {
remotePort = pachdRemotePort
}
return f.Run("pachd", localPort, remotePort)
} | go | {
"resource": ""
} |
q177729 | RunForSAMLACS | test | func (f *PortForwarder) RunForSAMLACS(localPort uint16) error {
if localPort == 0 {
localPort = samlAcsLocalPort
}
return f.Run("pachd", localPort, 654)
} | go | {
"resource": ""
} |
q177730 | RunForDashUI | test | func (f *PortForwarder) RunForDashUI(localPort uint16) error {
if localPort == 0 {
localPort = dashUILocalPort
}
return f.Run("dash", localPort, 8080)
} | go | {
"resource": ""
} |
q177731 | RunForDashWebSocket | test | func (f *PortForwarder) RunForDashWebSocket(localPort uint16) error {
if localPort == 0 {
localPort = dashWebSocketLocalPort
}
return f.Run("dash", localPort, 8081)
} | go | {
"resource": ""
} |
q177732 | RunForPFS | test | func (f *PortForwarder) RunForPFS(localPort uint16) error {
if localPort == 0 {
localPort = pfsLocalPort
}
return f.Run("pachd", localPort, 30652)
} | go | {
"resource": ""
} |
q177733 | RunForS3Gateway | test | func (f *PortForwarder) RunForS3Gateway(localPort uint16) error {
if localPort == 0 {
localPort = s3gatewayLocalPort
}
return f.Run("pachd", localPort, 600)
} | go | {
"resource": ""
} |
q177734 | Lock | test | func (f *PortForwarder) Lock() error {
pidfile.SetPidfilePath(path.Join(os.Getenv("HOME"), ".pachyderm/port-forward.pid"))
return pidfile.Write()
} | go | {
"resource": ""
} |
q177735 | Close | test | func (f *PortForwarder) Close() {
defer f.logger.Close()
f.stopChansLock.Lock()
defer f.stopChansLock.Unlock()
if f.shutdown {
panic("port forwarder already shutdown")
}
f.shutdown = true
for _, stopChan := range f.stopChans {
close(stopChan)
}
} | go | {
"resource": ""
} |
q177736 | Unmarshal | test | func (e *Event) Unmarshal(key *string, val proto.Message) error {
if err := CheckType(e.Template, val); err != nil {
return err
}
*key = string(e.Key)
return proto.Unmarshal(e.Value, val)
} | go | {
"resource": ""
} |
q177737 | UnmarshalPrev | test | func (e *Event) UnmarshalPrev(key *string, val proto.Message) error {
if err := CheckType(e.Template, val); err != nil {
return err
}
*key = string(e.PrevKey)
return proto.Unmarshal(e.PrevValue, val)
} | go | {
"resource": ""
} |
q177738 | MakeWatcher | test | func MakeWatcher(eventCh chan *Event, done chan struct{}) Watcher {
return &watcher{
eventCh: eventCh,
done: done,
}
} | go | {
"resource": ""
} |
q177739 | CheckType | test | func CheckType(template proto.Message, val interface{}) error {
if template != nil {
valType, templateType := reflect.TypeOf(val), reflect.TypeOf(template)
if valType != templateType {
return fmt.Errorf("invalid type, got: %s, expected: %s", valType, templateType)
}
}
return nil
} | go | {
"resource": ""
} |
q177740 | NewPool | test | func NewPool(kubeClient *kube.Clientset, namespace string, serviceName string, port int, queueSize int64, opts ...grpc.DialOption) (*Pool, error) {
endpointsInterface := kubeClient.CoreV1().Endpoints(namespace)
watch, err := endpointsInterface.Watch(metav1.ListOptions{
LabelSelector: metav1.FormatLabelSelector(met... | go | {
"resource": ""
} |
q177741 | Do | test | func (p *Pool) Do(ctx context.Context, f func(cc *grpc.ClientConn) error) error {
var conn *connCount
if err := func() error {
p.connsLock.Lock()
defer p.connsLock.Unlock()
for {
for addr, mapConn := range p.conns {
if mapConn.cc == nil {
cc, err := grpc.DialContext(ctx, addr, p.opts...)
if err... | go | {
"resource": ""
} |
q177742 | Close | test | func (p *Pool) Close() error {
close(p.done)
var retErr error
for _, conn := range p.conns {
if conn.cc != nil {
if err := conn.cc.Close(); err != nil {
retErr = err
}
}
}
return retErr
} | go | {
"resource": ""
} |
q177743 | buildImage | test | func buildImage(client *docker.Client, repo string, contextDir string, dockerfile string, destTag string) error {
destImage := fmt.Sprintf("%s:%s", repo, destTag)
fmt.Printf("Building %s, this may take a while.\n", destImage)
err := client.BuildImage(docker.BuildImageOptions{
Name: destImage,
ContextDi... | go | {
"resource": ""
} |
q177744 | pushImage | test | func pushImage(client *docker.Client, authConfig docker.AuthConfiguration, repo string, sourceTag string, destTag string) (string, error) {
sourceImage := fmt.Sprintf("%s:%s", repo, sourceTag)
destImage := fmt.Sprintf("%s:%s", repo, destTag)
fmt.Printf("Tagging/pushing %s, this may take a while.\n", destImage)
if... | go | {
"resource": ""
} |
q177745 | newMinioClient | test | func newMinioClient(endpoint, bucket, id, secret string, secure bool) (*minioClient, error) {
mclient, err := minio.New(endpoint, id, secret, secure)
if err != nil {
return nil, err
}
return &minioClient{
bucket: bucket,
Client: mclient,
}, nil
} | go | {
"resource": ""
} |
q177746 | newMinioClientV2 | test | func newMinioClientV2(endpoint, bucket, id, secret string, secure bool) (*minioClient, error) {
mclient, err := minio.NewV2(endpoint, id, secret, secure)
if err != nil {
return nil, err
}
return &minioClient{
bucket: bucket,
Client: mclient,
}, nil
} | go | {
"resource": ""
} |
q177747 | newMinioWriter | test | func newMinioWriter(ctx context.Context, client *minioClient, name string) *minioWriter {
reader, writer := io.Pipe()
w := &minioWriter{
ctx: ctx,
errChan: make(chan error),
pipe: writer,
}
go func() {
_, err := client.PutObject(client.bucket, name, reader, "application/octet-stream")
if err != nil... | go | {
"resource": ""
} |
q177748 | Close | test | func (w *minioWriter) Close() error {
span, _ := tracing.AddSpanToAnyExisting(w.ctx, "minioWriter.Close")
defer tracing.FinishAnySpan(span)
if err := w.pipe.Close(); err != nil {
return err
}
return <-w.errChan
} | go | {
"resource": ""
} |
q177749 | PipelineRepo | test | func PipelineRepo(pipeline *ppsclient.Pipeline) *pfs.Repo {
return &pfs.Repo{Name: pipeline.Name}
} | go | {
"resource": ""
} |
q177750 | PipelineRcName | test | func PipelineRcName(name string, version uint64) string {
// k8s won't allow RC names that contain upper-case letters
// or underscores
// TODO: deal with name collision
name = strings.Replace(name, "_", "-", -1)
return fmt.Sprintf("pipeline-%s-v%d", strings.ToLower(name), version)
} | go | {
"resource": ""
} |
q177751 | GetRequestsResourceListFromPipeline | test | func GetRequestsResourceListFromPipeline(pipelineInfo *pps.PipelineInfo) (*v1.ResourceList, error) {
return getResourceListFromSpec(pipelineInfo.ResourceRequests, pipelineInfo.CacheSize)
} | go | {
"resource": ""
} |
q177752 | GetLimitsResourceListFromPipeline | test | func GetLimitsResourceListFromPipeline(pipelineInfo *pps.PipelineInfo) (*v1.ResourceList, error) {
return getResourceListFromSpec(pipelineInfo.ResourceLimits, pipelineInfo.CacheSize)
} | go | {
"resource": ""
} |
q177753 | getNumNodes | test | func getNumNodes(kubeClient *kube.Clientset) (int, error) {
nodeList, err := kubeClient.CoreV1().Nodes().List(metav1.ListOptions{})
if err != nil {
return 0, fmt.Errorf("unable to retrieve node list from k8s to determine parallelism: %v", err)
}
if len(nodeList.Items) == 0 {
return 0, fmt.Errorf("pachyderm.pps.... | go | {
"resource": ""
} |
q177754 | GetExpectedNumWorkers | test | func GetExpectedNumWorkers(kubeClient *kube.Clientset, spec *ppsclient.ParallelismSpec) (int, error) {
if spec == nil || (spec.Constant == 0 && spec.Coefficient == 0) {
return 1, nil
} else if spec.Constant > 0 && spec.Coefficient == 0 {
return int(spec.Constant), nil
} else if spec.Constant == 0 && spec.Coeffic... | go | {
"resource": ""
} |
q177755 | GetExpectedNumHashtrees | test | func GetExpectedNumHashtrees(spec *ppsclient.HashtreeSpec) (int64, error) {
if spec == nil || spec.Constant == 0 {
return 1, nil
} else if spec.Constant > 0 {
return int64(spec.Constant), nil
}
return 0, fmt.Errorf("unable to interpret HashtreeSpec %+v", spec)
} | go | {
"resource": ""
} |
q177756 | FailPipeline | test | func FailPipeline(ctx context.Context, etcdClient *etcd.Client, pipelinesCollection col.Collection, pipelineName string, reason string) error {
_, err := col.NewSTM(ctx, etcdClient, func(stm col.STM) error {
pipelines := pipelinesCollection.ReadWrite(stm)
pipelinePtr := new(pps.EtcdPipelineInfo)
if err := pipeli... | go | {
"resource": ""
} |
q177757 | JobInput | test | func JobInput(pipelineInfo *pps.PipelineInfo, outputCommitInfo *pfs.CommitInfo) *pps.Input {
// branchToCommit maps strings of the form "<repo>/<branch>" to PFS commits
branchToCommit := make(map[string]*pfs.Commit)
key := path.Join
for _, prov := range outputCommitInfo.Provenance {
branchToCommit[key(prov.Commit... | go | {
"resource": ""
} |
q177758 | PipelineReqFromInfo | test | func PipelineReqFromInfo(pipelineInfo *ppsclient.PipelineInfo) *ppsclient.CreatePipelineRequest {
return &ppsclient.CreatePipelineRequest{
Pipeline: pipelineInfo.Pipeline,
Transform: pipelineInfo.Transform,
ParallelismSpec: pipelineInfo.ParallelismSpec,
HashtreeSpec: pipelineInfo.Ha... | go | {
"resource": ""
} |
q177759 | NewPipelineManifestReader | test | func NewPipelineManifestReader(path string) (result *PipelineManifestReader, retErr error) {
result = &PipelineManifestReader{}
var pipelineReader io.Reader
if path == "-" {
pipelineReader = io.TeeReader(os.Stdin, &result.buf)
fmt.Print("Reading from stdin.\n")
} else if url, err := url.Parse(path); err == nil ... | go | {
"resource": ""
} |
q177760 | NextCreatePipelineRequest | test | func (r *PipelineManifestReader) NextCreatePipelineRequest() (*ppsclient.CreatePipelineRequest, error) {
var result ppsclient.CreatePipelineRequest
if err := jsonpb.UnmarshalNext(r.decoder, &result); err != nil {
if err == io.EOF {
return nil, err
}
return nil, fmt.Errorf("malformed pipeline spec: %s", err)
... | go | {
"resource": ""
} |
q177761 | DescribeSyntaxError | test | func DescribeSyntaxError(originalErr error, parsedBuffer bytes.Buffer) error {
sErr, ok := originalErr.(*json.SyntaxError)
if !ok {
return originalErr
}
buffer := make([]byte, sErr.Offset)
parsedBuffer.Read(buffer)
lineOffset := strings.LastIndex(string(buffer[:len(buffer)-1]), "\n")
if lineOffset == -1 {
... | go | {
"resource": ""
} |
q177762 | UpdateJobState | test | func UpdateJobState(pipelines col.ReadWriteCollection, jobs col.ReadWriteCollection, jobPtr *pps.EtcdJobInfo, state pps.JobState, reason string) error {
// Update pipeline
pipelinePtr := &pps.EtcdPipelineInfo{}
if err := pipelines.Get(jobPtr.Pipeline.Name, pipelinePtr); err != nil {
return err
}
if pipelinePtr.J... | go | {
"resource": ""
} |
q177763 | New | test | func New() string {
var result string
backoff.RetryNotify(func() error {
uuid, err := uuid.NewV4()
if err != nil {
return err
}
result = uuid.String()
return nil
}, backoff.NewInfiniteBackOff(), func(err error, d time.Duration) error {
fmt.Printf("error from uuid.NewV4: %v", err)
return nil
})
ret... | go | {
"resource": ""
} |
q177764 | Code | test | func (h *HTTPError) Code() int {
if h == nil {
return http.StatusOK
}
return h.code
} | go | {
"resource": ""
} |
q177765 | NewHTTPError | test | func NewHTTPError(code int, formatStr string, args ...interface{}) *HTTPError {
return &HTTPError{
code: code,
err: fmt.Sprintf(formatStr, args...),
}
} | go | {
"resource": ""
} |
q177766 | NewStorage | test | func NewStorage(objC obj.Client, prefix string) *Storage {
return &Storage{
objC: objC,
prefix: prefix,
}
} | go | {
"resource": ""
} |
q177767 | DeleteAll | test | func (s *Storage) DeleteAll(ctx context.Context) error {
return s.objC.Walk(ctx, s.prefix, func(hash string) error {
return s.objC.Delete(ctx, hash)
})
} | go | {
"resource": ""
} |
q177768 | Chunk | test | func Chunk(data []byte, chunkSize int) [][]byte {
var result [][]byte
for i := 0; i < len(data); i += chunkSize {
end := i + chunkSize
if end > len(data) {
end = len(data)
}
result = append(result, data[i:end])
}
return result
} | go | {
"resource": ""
} |
q177769 | ChunkReader | test | func ChunkReader(r io.Reader, f func([]byte) error) (int, error) {
var total int
buf := GetBuffer()
defer PutBuffer(buf)
for {
n, err := r.Read(buf)
if n == 0 && err != nil {
if err == io.EOF {
return total, nil
}
return total, err
}
if err := f(buf[:n]); err != nil {
return total, err
}
... | go | {
"resource": ""
} |
q177770 | NewStreamingBytesReader | test | func NewStreamingBytesReader(streamingBytesClient StreamingBytesClient, cancel context.CancelFunc) io.ReadCloser {
return &streamingBytesReader{streamingBytesClient: streamingBytesClient, cancel: cancel}
} | go | {
"resource": ""
} |
q177771 | WriteToStreamingBytesServer | test | func WriteToStreamingBytesServer(reader io.Reader, streamingBytesServer StreamingBytesServer) error {
buf := GetBuffer()
defer PutBuffer(buf)
_, err := io.CopyBuffer(NewStreamingBytesWriter(streamingBytesServer), ReaderWrapper{reader}, buf)
return err
} | go | {
"resource": ""
} |
q177772 | WriteFromStreamingBytesClient | test | func WriteFromStreamingBytesClient(streamingBytesClient StreamingBytesClient, writer io.Writer) error {
for bytesValue, err := streamingBytesClient.Recv(); err != io.EOF; bytesValue, err = streamingBytesClient.Recv() {
if err != nil {
return err
}
if _, err = writer.Write(bytesValue.Value); err != nil {
re... | go | {
"resource": ""
} |
q177773 | NewSidecarAPIServer | test | func NewSidecarAPIServer(
env *serviceenv.ServiceEnv,
etcdPrefix string,
iamRole string,
reporter *metrics.Reporter,
workerGrpcPort uint16,
pprofPort uint16,
httpPort uint16,
peerPort uint16,
) (ppsclient.APIServer, error) {
apiServer := &apiServer{
Logger: log.NewLogger("pps.API"),
env: ... | go | {
"resource": ""
} |
q177774 | NewEnterpriseServer | test | func NewEnterpriseServer(env *serviceenv.ServiceEnv, etcdPrefix string) (ec.APIServer, error) {
s := &apiServer{
pachLogger: log.NewLogger("enterprise.API"),
env: env,
enterpriseToken: col.NewCollection(
env.GetEtcdClient(),
etcdPrefix, // only one collection--no extra prefix needed
nil,
&ec.E... | go | {
"resource": ""
} |
q177775 | validateActivationCode | test | func validateActivationCode(code string) (expiration time.Time, err error) {
// Parse the public key. If these steps fail, something is seriously
// wrong and we should crash the service by panicking.
block, _ := pem.Decode([]byte(publicKey))
if block == nil {
return time.Time{}, fmt.Errorf("failed to pem decode... | go | {
"resource": ""
} |
q177776 | Activate | test | func (a *apiServer) Activate(ctx context.Context, req *ec.ActivateRequest) (resp *ec.ActivateResponse, retErr error) {
a.LogReq(req)
defer func(start time.Time) { a.pachLogger.Log(req, resp, retErr, time.Since(start)) }(time.Now())
// Validate the activation code
expiration, err := validateActivationCode(req.Activ... | go | {
"resource": ""
} |
q177777 | Deactivate | test | func (a *apiServer) Deactivate(ctx context.Context, req *ec.DeactivateRequest) (resp *ec.DeactivateResponse, retErr error) {
a.LogReq(req)
defer func(start time.Time) { a.pachLogger.Log(req, resp, retErr, time.Since(start)) }(time.Now())
pachClient := a.env.GetPachClient(ctx)
if err := pachClient.DeleteAll(); err ... | go | {
"resource": ""
} |
q177778 | lookExtensions | test | func lookExtensions(path, dir string) (string, error) {
if filepath.Base(path) == path {
path = filepath.Join(".", path)
}
if dir == "" {
return exec.LookPath(path)
}
if filepath.VolumeName(path) != "" {
return exec.LookPath(path)
}
if len(path) > 1 && os.IsPathSeparator(path[0]) {
return exec.LookPath(p... | go | {
"resource": ""
} |
q177779 | Start | test | func (c *Cmd) Start() error {
if c.lookPathErr != nil {
c.closeDescriptors(c.closeAfterStart)
c.closeDescriptors(c.closeAfterWait)
return c.lookPathErr
}
if runtime.GOOS == "windows" {
lp, err := lookExtensions(c.Path, c.Dir)
if err != nil {
c.closeDescriptors(c.closeAfterStart)
c.closeDescriptors(c.... | go | {
"resource": ""
} |
q177780 | CombinedOutput | test | func (c *Cmd) CombinedOutput() ([]byte, error) {
if c.Stdout != nil {
return nil, errors.New("exec: Stdout already set")
}
if c.Stderr != nil {
return nil, errors.New("exec: Stderr already set")
}
var b bytes.Buffer
c.Stdout = &b
c.Stderr = &b
err := c.Run()
return b.Bytes(), err
} | go | {
"resource": ""
} |
q177781 | StdinPipe | test | func (c *Cmd) StdinPipe() (io.WriteCloser, error) {
if c.Stdin != nil {
return nil, errors.New("exec: Stdin already set")
}
if c.Process != nil {
return nil, errors.New("exec: StdinPipe after process started")
}
pr, pw, err := os.Pipe()
if err != nil {
return nil, err
}
c.Stdin = pr
c.closeAfterStart = a... | go | {
"resource": ""
} |
q177782 | StdoutPipe | test | func (c *Cmd) StdoutPipe() (io.ReadCloser, error) {
if c.Stdout != nil {
return nil, errors.New("exec: Stdout already set")
}
if c.Process != nil {
return nil, errors.New("exec: StdoutPipe after process started")
}
pr, pw, err := os.Pipe()
if err != nil {
return nil, err
}
c.Stdout = pw
c.closeAfterStart... | go | {
"resource": ""
} |
q177783 | dedupEnvCase | test | func dedupEnvCase(caseInsensitive bool, env []string) []string {
out := make([]string, 0, len(env))
saw := map[string]int{} // key => index into out
for _, kv := range env {
eq := strings.Index(kv, "=")
if eq < 0 {
out = append(out, kv)
continue
}
k := kv[:eq]
if caseInsensitive {
k = strings.ToLo... | go | {
"resource": ""
} |
q177784 | InputName | test | func InputName(input *Input) string {
switch {
case input == nil:
return ""
case input.Pfs != nil:
return input.Pfs.Name
case input.Cross != nil:
if len(input.Cross) > 0 {
return InputName(input.Cross[0])
}
case input.Union != nil:
if len(input.Union) > 0 {
return InputName(input.Union[0])
}
}
... | go | {
"resource": ""
} |
q177785 | SortInput | test | func SortInput(input *Input) {
VisitInput(input, func(input *Input) {
SortInputs := func(inputs []*Input) {
sort.SliceStable(inputs, func(i, j int) bool { return InputName(inputs[i]) < InputName(inputs[j]) })
}
switch {
case input.Cross != nil:
SortInputs(input.Cross)
case input.Union != nil:
SortIn... | go | {
"resource": ""
} |
q177786 | InputBranches | test | func InputBranches(input *Input) []*pfs.Branch {
var result []*pfs.Branch
VisitInput(input, func(input *Input) {
if input.Pfs != nil {
result = append(result, &pfs.Branch{
Repo: &pfs.Repo{Name: input.Pfs.Repo},
Name: input.Pfs.Branch,
})
}
if input.Cron != nil {
result = append(result, &pfs.Bra... | go | {
"resource": ""
} |
q177787 | ValidateGitCloneURL | test | func ValidateGitCloneURL(url string) error {
exampleURL := "https://github.com/org/foo.git"
if url == "" {
return fmt.Errorf("clone URL is missing (example clone URL %v)", exampleURL)
}
// Use the git client's validator to make sure its a valid URL
o := &git.CloneOptions{
URL: url,
}
if err := o.Validate(); ... | go | {
"resource": ""
} |
q177788 | containsEmpty | test | func containsEmpty(vals []string) bool {
for _, val := range vals {
if val == "" {
return true
}
}
return false
} | go | {
"resource": ""
} |
q177789 | NewAPIServer | test | func NewAPIServer(address string, storageRoot string, clusterInfo *admin.ClusterInfo) APIServer {
return &apiServer{
Logger: log.NewLogger("admin.API"),
address: address,
storageRoot: storageRoot,
clusterInfo: clusterInfo,
}
} | go | {
"resource": ""
} |
q177790 | Ago | test | func Ago(timestamp *types.Timestamp) string {
t, _ := types.TimestampFromProto(timestamp)
if t.Equal(time.Time{}) {
return ""
}
return fmt.Sprintf("%s ago", units.HumanDuration(time.Since(t)))
} | go | {
"resource": ""
} |
q177791 | TimeDifference | test | func TimeDifference(from *types.Timestamp, to *types.Timestamp) string {
tFrom, _ := types.TimestampFromProto(from)
tTo, _ := types.TimestampFromProto(to)
return units.HumanDuration(tTo.Sub(tFrom))
} | go | {
"resource": ""
} |
q177792 | Duration | test | func Duration(d *types.Duration) string {
duration, _ := types.DurationFromProto(d)
return units.HumanDuration(duration)
} | go | {
"resource": ""
} |
q177793 | InspectCluster | test | func (c APIClient) InspectCluster() (*admin.ClusterInfo, error) {
clusterInfo, err := c.AdminAPIClient.InspectCluster(c.Ctx(), &types.Empty{})
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
return clusterInfo, nil
} | go | {
"resource": ""
} |
q177794 | Extract | test | func (c APIClient) Extract(objects bool, f func(op *admin.Op) error) error {
extractClient, err := c.AdminAPIClient.Extract(c.Ctx(), &admin.ExtractRequest{NoObjects: !objects})
if err != nil {
return grpcutil.ScrubGRPC(err)
}
for {
op, err := extractClient.Recv()
if err == io.EOF {
break
}
if err != ni... | go | {
"resource": ""
} |
q177795 | ExtractAll | test | func (c APIClient) ExtractAll(objects bool) ([]*admin.Op, error) {
var result []*admin.Op
if err := c.Extract(objects, func(op *admin.Op) error {
result = append(result, op)
return nil
}); err != nil {
return nil, err
}
return result, nil
} | go | {
"resource": ""
} |
q177796 | ExtractWriter | test | func (c APIClient) ExtractWriter(objects bool, w io.Writer) error {
writer := pbutil.NewWriter(w)
return c.Extract(objects, func(op *admin.Op) error {
_, err := writer.Write(op)
return err
})
} | go | {
"resource": ""
} |
q177797 | ExtractURL | test | func (c APIClient) ExtractURL(url string) error {
extractClient, err := c.AdminAPIClient.Extract(c.Ctx(), &admin.ExtractRequest{URL: url})
if err != nil {
return grpcutil.ScrubGRPC(err)
}
resp, err := extractClient.Recv()
if err == nil {
return fmt.Errorf("unexpected response from extract: %v", resp)
}
if er... | go | {
"resource": ""
} |
q177798 | ExtractPipeline | test | func (c APIClient) ExtractPipeline(pipelineName string) (*pps.CreatePipelineRequest, error) {
op, err := c.AdminAPIClient.ExtractPipeline(c.Ctx(), &admin.ExtractPipelineRequest{Pipeline: NewPipeline(pipelineName)})
if err != nil {
return nil, grpcutil.ScrubGRPC(err)
}
if op.Op1_9 == nil || op.Op1_9.Pipeline == ni... | go | {
"resource": ""
} |
q177799 | Restore | test | func (c APIClient) Restore(ops []*admin.Op) (retErr error) {
restoreClient, err := c.AdminAPIClient.Restore(c.Ctx())
if err != nil {
return grpcutil.ScrubGRPC(err)
}
defer func() {
if _, err := restoreClient.CloseAndRecv(); err != nil && retErr == nil {
retErr = grpcutil.ScrubGRPC(err)
}
}()
for _, op :=... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.