// getSteps fetches steps of the build.
500395
func (r *logRun) getSteps(ctx context.Context) ([]*pb.Step, error) {
	r.getBuild.Fields = &field_mask.FieldMask{Paths: []string{"steps"}}
	build, err := r.client.GetBuild(ctx, r.getBuild, prpc.ExpectedCode(codes.NotFound))
	switch status.Code(err) {
	case codes.OK:
		return build.Steps, nil
	case codes.NotFound:
		return nil, fmt.Errorf("build not found")
	default:
		return nil, err
	}
}
408467
func GetAllStepCollectionPath() []string {
	routes, err := readRouteMap()
	if err != nil {
		log.Errorf("Failed to read step specs path, error: %s", err)
		return []string{}
	}

	sources := []string{}
	for _, route := range routes {
		sources = append(sources, route.SteplibURI)
	}

	return sources
}
70091
func (t *Template) GetAllAWSStepFunctionsActivityResources() map[string]*resources.AWSStepFunctionsActivity {
	results := map[string]*resources.AWSStepFunctionsActivity{}
	for name, untyped := range t.Resources {
		switch resource := untyped.(type) {
		case *resources.AWSStepFunctionsActivity:
			results[name] = resource
		}
	}
	return results
}
898097
func (s *Job) SetSteps(v []*Step) *Job {
	s.Steps = v
	return s
}
57510
func (c Client) GetBuild(ctx context.Context, name string, options *metav1.GetOptions) (*buildv1.Build, error) {
	return c.Builds.Builds(apirequest.NamespaceValue(ctx)).Get(name, *options)
}
938205
func (cs *CommitsService) GetFromBuild(buildId uint) (*Commit, *http.Response, error) {
	u, err := urlWithOptions(fmt.Sprintf("/builds/%d", buildId), nil)
	if err != nil {
		return nil, nil, err
	}

	req, err := cs.client.NewRequest("GET", u, nil, nil)
	if err != nil {
		return nil, nil, err
	}

	var buildResp getBuildResponse
	resp, err := cs.client.Do(req, &buildResp)
	if err != nil {
		return nil, resp, err
	}

	return &buildResp.Commit, resp, nil
}
502439
func (s *MaintenanceWindowTaskInvocationParameters) SetStepFunctions(v *MaintenanceWindowStepFunctionsParameters) *MaintenanceWindowTaskInvocationParameters {
	s.StepFunctions = v
	return s
}
522045
func (lifecycle *Lifecycle) NextStep(step int) {
	lifecycle.muStep.Lock()
	lifecycle.step = step
	lifecycle.muStep.Unlock()
}
617202
func (s *Action) SetStepFunctions(v *StepFunctionsAction) *Action {
	s.StepFunctions = v
	return s
}
1086828
func GetStep(s Step) string {
	return fmt.Sprintf("{\"sequence\"=>\"%d\",\"state\"=>\"%s\",\"errors\"=>%s,\"warnings\"=>%s,\"operation\"=>\"%s\","+
		"\"startedTime\"=>\"%d\",\"queuedTime\"=>\"%d\",\"endTime\"=>\"%d\",\"options\"=>%s}",
		s.Sequence, s.State, s.Errors, s.Warnings, s.Operation, s.StartedTime, s.QueuedTime,
		s.EndTime, s.Options)

}
1168715
func Convert_build_StepInfo_To_v1_StepInfo(in *build.StepInfo, out *v1.StepInfo, s conversion.Scope) error {
	return autoConvert_build_StepInfo_To_v1_StepInfo(in, out, s)
}
1249925
func (i *Import) GetFailedStep() string {
	if i == nil || i.FailedStep == nil {
		return ""
	}
	return *i.FailedStep
}
668247
func stepsFor245() []Step {
	return []Step{
		&upgradeStep{
			description: "update exec.start.sh log path if incorrect",
			targets:     []Target{AllMachines},
			run:         correctServiceFileLogPath,
		},
	}
}
7916
func (m *MockBuildsClient) GetBuild(ctx context.Context, in *GetBuildRequest, opts ...grpc.CallOption) (*Build, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBuild", varargs...)
	ret0, _ := ret[0].(*Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
488590
func (s *RunJobFlowInput) SetSteps(v []*StepConfig) *RunJobFlowInput {
	s.Steps = v
	return s
}
1059467
func GetStack() []byte {
	const size = 4096
	buf := make([]byte, size)
	stackSize := runtime.Stack(buf, false)
	buf = buf[:stackSize]
	return buf
}
1144394
func GetBuilders(c context.Context) (*swarmbucket.LegacySwarmbucketApiGetBuildersResponseMessage, error) {
	host := common.GetSettings(c).GetBuildbucket().GetHost()
	if host == "" {
		return nil, errors.New("buildbucket host is missing in config")
	}
	return getBuilders(c, host)
}