Class: Smplkit::Jobs::Run

Inherits:
Struct
  • Object
show all
Defined in:
lib/smplkit/jobs/models.rb

Overview

A single execution of a job (read-only) with rerun / cancel actions.

Runs are created and mutated by the jobs service, not by clients; clients influence runs only through #rerun / #cancel (and the run action on client.jobs). A run returned from the SDK holds a backref to the runs client so #rerun / #cancel work without re-deriving the client.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#created_at ⇒ String?

Returns When the run was enqueued (became PENDING).

Returns:

  • (String, nil) —

    When the run was enqueued (became PENDING).



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#environment ⇒ String

Returns The environment this run executed in. A scheduled run inherits the firing job-environment; a manual run uses the environment named on the run-now request; a rerun copies its source run’s environment.

Returns:

  • (String) —

    The environment this run executed in. A scheduled run inherits the firing job-environment; a manual run uses the environment named on the run-now request; a rerun copies its source run’s environment.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#error ⇒ String?

Returns Free-text failure detail, if any.

Returns:

  • (String, nil) —

    Free-text failure detail, if any.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#failure_reason ⇒ String?

Returns Why a FAILED run failed; nil otherwise.

Returns:

  • (String, nil) —

    Why a FAILED run failed; nil otherwise.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#finished_at ⇒ String?

Returns When execution finished.

Returns:

  • (String, nil) —

    When execution finished.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#id ⇒ String

Returns Server-assigned UUID for this run.

Returns:

  • (String) —

    Server-assigned UUID for this run.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#job ⇒ String

Returns The id of the job this run belongs to.

Returns:

  • (String) —

    The id of the job this run belongs to.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#job_version ⇒ Integer?

Returns The job’s version at the time the run executed.

Returns:

  • (Integer, nil) —

    The job’s version at the time the run executed.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#pending_duration_ms ⇒ Integer?

Returns Milliseconds the run waited as PENDING before starting.

Returns:

  • (Integer, nil) —

    Milliseconds the run waited as PENDING before starting.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#request ⇒ Hash?

Returns Snapshot of the request that was sent (header values redacted).

Returns:

  • (Hash, nil) —

    Snapshot of the request that was sent (header values redacted).



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#rerun_of ⇒ String?

Returns The source run’s id; set only when trigger is RERUN.

Returns:

  • (String, nil) —

    The source run’s id; set only when trigger is RERUN.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#result ⇒ Hash?

Returns Outcome of the call (status, headers, body, …).

Returns:

  • (Hash, nil) —

    Outcome of the call (status, headers, body, …).



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#run_duration_ms ⇒ Integer?

Returns Milliseconds the run spent executing.

Returns:

  • (Integer, nil) —

    Milliseconds the run spent executing.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#scheduled_for ⇒ String?

Returns The intended fire time for a scheduled run; nil for manual / rerun runs.

Returns:

  • (String, nil) —

    The intended fire time for a scheduled run; nil for manual / rerun runs.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#started_at ⇒ String?

Returns When execution started.

Returns:

  • (String, nil) —

    When execution started.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#status ⇒ String

Returns Lifecycle state of the run.

Returns:

  • (String) —

    Lifecycle state of the run.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#total_duration_ms ⇒ Integer?

Returns Milliseconds from enqueue to finish.

Returns:

  • (Integer, nil) —

    Milliseconds from enqueue to finish.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

#trigger ⇒ String

Returns Why the run exists — a raw string equal to one of the Smplkit::Jobs::RunTrigger constants: SCHEDULE, MANUAL (run now), or RERUN.

Returns:

  • (String) —

    Why the run exists — a raw string equal to one of the Smplkit::Jobs::RunTrigger constants: SCHEDULE, MANUAL (run now), or RERUN.



769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/smplkit/jobs/models.rb', line 769

Run = Struct.new(
  :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
  :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
  :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
  keyword_init: true
) do
  # @api private — Build a {Run} from a JSON:API resource returned by the
  #   jobs service, binding it to +runs+ so {#rerun} / {#cancel} work.
  #
  # @param resource [Object] The JSON:API resource (id + attributes).
  # @param runs [RunsClient, nil] Runs client to bind the run to.
  # @return [Run] The hydrated run.
  def self.from_resource(resource, runs: nil)
    a = resource.attributes
    new(
      id: resource.id,
      job: a.job,
      job_version: a.job_version,
      environment: a.environment,
      trigger: a.trigger,
      rerun_of: a.rerun_of,
      scheduled_for: a.scheduled_for,
      status: a.status,
      started_at: a.started_at,
      finished_at: a.finished_at,
      pending_duration_ms: a.pending_duration_ms,
      run_duration_ms: a.run_duration_ms,
      total_duration_ms: a.total_duration_ms,
      failure_reason: a.failure_reason,
      error: a.error,
      request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
      result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
      created_at: a.created_at
    ).tap { |run| run.instance_variable_set(:@runs, runs) }
  end

  # Start a new run that repeats this one (a +RERUN+), in the same
  # environment.
  #
  # @return [Smplkit::Jobs::Run] The new run, with +rerun_of+ set to this
  #   run's id.
  # @raise [RuntimeError] when this run has no bound runs client.
  def rerun
    raise "Run was constructed without a client; cannot rerun" if @runs.nil?

    @runs.rerun(id)
  end

  # Cancel this run if it has not finished yet.
  #
  # @return [Smplkit::Jobs::Run] The updated run reflecting the cancellation.
  # @raise [RuntimeError] when this run has no bound runs client.
  def cancel
    raise "Run was constructed without a client; cannot cancel" if @runs.nil?

    @runs.cancel(id)
  end
end

Class Method Details

.from_resource(resource, runs: nil) ⇒ Run

Returns The hydrated run.

Parameters:

  • resource (Object) —

    The JSON:API resource (id + attributes).

  • runs (RunsClient, nil) (defaults to: nil) —

    Runs client to bind the run to.

Returns:

  • (Run) —

    The hydrated run.



781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
 
# File 'lib/smplkit/jobs/models.rb', line 781

def self.from_resource(resource, runs: nil)
  a = resource.attributes
  new(
    id: resource.id,
    job: a.job,
    job_version: a.job_version,
    environment: a.environment,
    trigger: a.trigger,
    rerun_of: a.rerun_of,
    scheduled_for: a.scheduled_for,
    status: a.status,
    started_at: a.started_at,
    finished_at: a.finished_at,
    pending_duration_ms: a.pending_duration_ms,
    run_duration_ms: a.run_duration_ms,
    total_duration_ms: a.total_duration_ms,
    failure_reason: a.failure_reason,
    error: a.error,
    request: a.request.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.request),
    result: a.result.nil? ? nil : Smplkit::Helpers.deep_stringify_keys(a.result),
    created_at: a.created_at
  ).tap { |run| run.instance_variable_set(:@runs, runs) }
end

Instance Method Details

#cancel ⇒ Smplkit::Jobs::Run

Cancel this run if it has not finished yet.

Returns:

Raises:

  • (RuntimeError) —

    when this run has no bound runs client.



821
822
823
824
825
 
# File 'lib/smplkit/jobs/models.rb', line 821

def cancel
  raise "Run was constructed without a client; cannot cancel" if @runs.nil?

  @runs.cancel(id)
end

#rerun ⇒ Smplkit::Jobs::Run

Start a new run that repeats this one (a RERUN), in the same environment.

Returns:

Raises:

  • (RuntimeError) —

    when this run has no bound runs client.



811
812
813
814
815
 
# File 'lib/smplkit/jobs/models.rb', line 811

def rerun
  raise "Run was constructed without a client; cannot rerun" if @runs.nil?

  @runs.rerun(id)
end