Package annotation implements a state machine that constructs Milo annotation protobufs from a series of annotation commands.

    The annotation state is represented by a State object. Annotation strings are appended to the State via Append(), causing the State to incorporate that annotation and advance. During state advancement, any number of the State's Callbacks may be invoked in response to changes that are made.

    State is pure (not bound to any I/O). Users of a State should interact with it by implementing Callbacks.



    This section is empty.


    This section is empty.


    This section is empty.


    type Callbacks

    type Callbacks interface {
    	// StepClosed is called when a Step has closed. An Updated callback will still
    	// be invoked.
    	// Updated is called when a Step's state has been updated.
    	Updated(*Step, UpdateType)
    	// StepLogLine is called when a Step emits a log line.
    	StepLogLine(s *Step, stream types.StreamName, label, line string)
    	// StepLogEnd is called when a Step finishes emitting logs.
    	StepLogEnd(*Step, types.StreamName)

      Callbacks is the set of callbacks that a State may invoke as it processes annotations.

      type Execution

      type Execution struct {
      	Name    string
      	Command []string
      	Dir     string
      	Env     map[string]string

        Execution describes the high-level execution metadata.

        func ProbeExecution

        func ProbeExecution(argv, env []string, cwd string) *Execution

          ProbeExecution loads Execution parameters by probing the current runtime environment.

          type State

          type State struct {
          	// LogNameBase is the base log stream name that is prepeneded to generated
          	// log streams.
          	LogNameBase types.StreamName
          	// Callbacks implements annotation callbacks. It may not be nil.
          	Callbacks Callbacks
          	// Execution is the supplied Execution. If nil, no execution details will be
          	// added to the generated annotation protos.
          	Execution *Execution
          	// Offline specifies whether parsing happens not at the same time as
          	// emitting. If true and CURRENT_TIMESTAMP annotations are not provided
          	// then step start/end times are left empty.
          	Offline bool
          	// Clock is the clock implementation to use for time information.
          	// Defaults to system time.
          	Clock clock.Clock
          	// contains filtered or unexported fields

            State is the aggregate annotation state for a given annotation stream. It receives updates in the form of annotations added via Append, and can be serialized to an annotation state protobuf.

            func (*State) Append

            func (s *State) Append(annotation string) error

              Append adds an annotation to the state. If the state was updated, Append will return true.

              The appended annotation should only contain the annotation text body, not any annotation indicators (e.g., "@@@") that surround it.

              If the annotation is invalid or could not be added to the state, an error will be returned.

              Steps and descriptions can be found at: master/

              func (*State) CurrentStep

              func (s *State) CurrentStep() *Step

                CurrentStep returns the step referenced by the step cursor.

                func (*State) Finish

                func (s *State) Finish()

                  Finish closes the top-level annotation state and any outstanding steps.

                  func (*State) LookupStep

                  func (s *State) LookupStep(name string) *Step

                    LookupStep returns the step with the supplied name, or nil if no such step exists.

                    If multiple steps share a name, this will return the latest registered step with that name.

                    func (*State) LookupStepErr

                    func (s *State) LookupStepErr(name string) (*Step, error)

                      LookupStepErr returns the step with the supplied name, or an error if no such step exists.

                      If multiple steps share a name, this will return the latest registered step with that name.

                      func (*State) ResolveStep

                      func (s *State) ResolveStep(ms *annopb.Step) *Step

                        ResolveStep returns the annotation package *Step corresponding to the supplied *annopb.Step. This is a reverse lookup operation.

                        If the supplied *annopb.Step is not registered with this annotation State, this function will return nil.

                        func (*State) RootStep

                        func (s *State) RootStep() *Step

                          RootStep returns the root step.

                          func (*State) SetCurrentStep

                          func (s *State) SetCurrentStep(v *Step)

                            SetCurrentStep sets the current step. If the supplied step is nil, the root step will be used.

                            The supplied step must already be registered with the State.

                            type Step

                            type Step struct {
                            	// logNameBase is the LogDog stream name root for this step.
                            	LogNameBase types.StreamName
                            	// contains filtered or unexported fields

                              Step represents a single step.

                              func (as *Step) AddLogdogStreamLink(server, label string, prefix, name types.StreamName)

                                AddLogdogStreamLink adds a LogDog stream link to this Step's links list.

                                func (*Step) AddStep

                                func (as *Step) AddStep(name string, legacy bool) *Step

                                  AddStep generates a new substep.

                                  func (*Step) AddText

                                  func (as *Step) AddText(text string) bool

                                    AddText adds a line of step component text.

                                    func (as *Step) AddURLLink(label, alias, url string)

                                      AddURLLink adds a URL link to this Step's links list.

                                      func (*Step) BaseStream

                                      func (as *Step) BaseStream(name types.StreamName) types.StreamName

                                        BaseStream returns the supplied name prepended with this Step's base log name.

                                        For example, if the base name is "foo/bar", BaseStream("baz") will return "foo/bar/baz".

                                        func (*Step) ClearSummary

                                        func (as *Step) ClearSummary()

                                          ClearSummary clears the step's summary text.

                                          func (*Step) ClearText

                                          func (as *Step) ClearText() bool

                                            ClearText clears step component text.

                                            func (*Step) Close

                                            func (as *Step) Close(closeTime *timestamp.Timestamp) bool

                                              Close closes this step and any outstanding resources that it owns. If it is already closed, does not have side effects and returns false.

                                              func (*Step) LogEnd

                                              func (as *Step) LogEnd(label string)

                                                LogEnd ends the log for the specified label.

                                                func (*Step) LogLine

                                                func (as *Step) LogLine(label, line string) bool

                                                  LogLine emits a log line for a specified log label.

                                                  func (*Step) Name

                                                  func (as *Step) Name() string

                                                    Name returns the step's component name.

                                                    func (*Step) Proto

                                                    func (as *Step) Proto() *annopb.Step

                                                      Proto returns the annotation Step protobuf associated with this Step.

                                                      func (*Step) SetNestLevel

                                                      func (as *Step) SetNestLevel(l int) bool

                                                        SetNestLevel sets the nest level of this Step, and identifies its nesting parent.

                                                        If no parent could be found at level "l-1", the root step will become the parent.

                                                        func (*Step) SetProperty

                                                        func (as *Step) SetProperty(name, value string) bool

                                                          SetProperty sets a key/value property for this Step.

                                                          func (*Step) SetSTDERRStream

                                                          func (as *Step) SetSTDERRStream(st *annopb.LogdogStream) (updated bool)

                                                            SetSTDERRStream sets the LogDog STDERR stream value, returning true if the Step was updated.

                                                            func (*Step) SetSTDOUTStream

                                                            func (as *Step) SetSTDOUTStream(st *annopb.LogdogStream) (updated bool)

                                                              SetSTDOUTStream sets the LogDog STDOUT stream value, returning true if the Step was updated.

                                                              func (*Step) SetStatus

                                                              func (as *Step) SetStatus(s annopb.Status, fd *annopb.FailureDetails) bool

                                                                SetStatus sets this step's component status.

                                                                If the status doesn't change, the supplied failure details will be ignored.

                                                                func (*Step) SetSummary

                                                                func (as *Step) SetSummary(value string) bool

                                                                  SetSummary sets the Step's summary text.

                                                                  The summary is implemented as the first line of step component text. If no summary is currently defined, one will be inserted; otherwise, the current summary will be replaced.

                                                                  func (*Step) Start

                                                                  func (as *Step) Start(startTime *timestamp.Timestamp) bool

                                                                    Start marks the Step as started.

                                                                    func (*Step) String

                                                                    func (as *Step) String() string

                                                                    type UpdateType

                                                                    type UpdateType int

                                                                      UpdateType is information sent to the Updated callback to indicate the nature of the update.

                                                                      const (
                                                                      	// UpdateIterative indicates that a non-structural update occurred.
                                                                      	UpdateIterative UpdateType = iota
                                                                      	// UpdateStructural indicates that a structural update has occurred. A
                                                                      	// structural update is one that affects the existence of or relationship of
                                                                      	// the Steps in the annotation.