Add specs and implement more runtime status stuff

Author: Knerio

app/graphql/types/runtime_status_type.rb

@@ -8,7 +8,7 @@ class RuntimeStatusType < Types::BaseObject
           null: false,
           description: 'The detailed configuration entries for this runtime status (only for adapters)',
           method: :runtime_status_configurations
-    field :feature_set, [String], null: false, description: 'The set of features supported by the runtime'
+    field :features, [String], null: false, description: 'The set of features supported by the runtime'
     field :identifier, String, null: false, description: 'The unique identifier for this runtime status'
     field :last_heartbeat, Types::TimeType, null: true,
                                             description: 'The timestamp of the last heartbeat received from the runtime'

app/grpc/flow_handler.rb

@@ -8,6 +8,9 @@ class FlowHandler < Tucana::Sagittarius::FlowService::Service
   grpc_stream :update
 
   def self.update_runtime(runtime)
+    runtime.last_heartbeat = Time.zone.now
+    runtime.save!
+
     flows = []
     runtime.project_assignments.compatible.each do |assignment|
       assignment.namespace_project.flows.each do |flow|

app/grpc/runtime_status_handler.rb

@@ -8,8 +8,8 @@ def update(request, _call)
     current_runtime = Runtime.find(Code0::ZeroTrack::Context.current[:runtime][:id])
 
     response = Runtimes::Grpc::RuntimeStatusUpdateService.new(
-      current_runtime,
-      request.status
+      runtime: current_runtime,
+      status_info: request.send(request.status)
     ).execute
 
     logger.debug("RuntimeFunctionHandler#update response: #{response.inspect}")

app/services/error_code.rb

@@ -88,6 +88,7 @@ def self.error_codes
       invalid_node_parameter: { description: 'The node parameter is invalid' },
       invalid_node_function: { description: 'The node function is invalid' },
       invalid_runtime_status: { description: 'The runtime status is invalid because of active model errors' },
+      invalid_runtime_status_configuration: { description: 'The runtime status configuration is invalid because of active model errors' },
 
       primary_level_not_found: { description: '', deprecation_reason: 'Outdated concept' },
       secondary_level_not_found: { description: '', deprecation_reason: 'Outdated concept' },

app/services/runtimes/grpc/runtime_status_update_service.rb

@@ -4,6 +4,7 @@ module Runtimes
   module Grpc
     class RuntimeStatusUpdateService
       include Sagittarius::Database::Transactional
+      include Code0::ZeroTrack::Loggable
 
       attr_reader :runtime, :status_info
 
@@ -24,45 +25,37 @@ def execute
             )
           end
 
-          db_status = RuntimeStatus.find_or_initialize_by(runtime: current_runtime,
+          db_status = RuntimeStatus.find_or_initialize_by(runtime: runtime,
                                                           identifier: status_info.identifier)
 
-          db_status.last_heartbeat = Time.zone.at(status_info.last_heartbeat.seconds)
+          db_status.last_heartbeat = Time.zone.at(status_info.timestamp.to_i)
           db_status.status_type = if status_info.is_a?(Tucana::Shared::AdapterRuntimeStatus)
                                     :adapter
                                   else
                                     :execution
                                   end
-          db_status.feature_set = status_info.feature_set.to_a
+          db_status.features = status_info.features.to_a
 
-          case status_info.status
-          when Tucana::Shared::Status::NOT_RESPONDING
-            db_status.status = :not_responding
-          when Tucana::Shared::Status::NOT_READY
-            db_status.status = :not_ready
-          when Tucana::Shared::Status::RUNNING
-            db_status.status = :running
-          when Tucana::Shared::Status::STOPPED
-            db_status.status = :stopped
-          else
-            logger.error("Unknown status received: #{status_info.status}")
-            t.rollback_and_return ServiceResponse.error(
-              message: 'Unknown status received',
-              error_code: :invalid_runtime_status,
-              details: { status: status_info.status }
-            )
-          end
+          db_status.status = status_info.status.downcase
 
           db_configs = db_status.runtime_status_configurations.first(status_info.configurations.size)
 
           status_info.configurations.each_with_index do |config, index|
             db_configs[index] ||= db_status.runtime_status_configurations.build
 
             db_configs[index].endpoint = config.endpoint
+
+            next if db_configs[index].save
+
+            t.rollback_and_return! ServiceResponse.error(
+              message: 'Failed to save runtime status configuration',
+              error_code: :invalid_runtime_status_configuration,
+              details: db_configs.errors
+            )
           end
 
           unless db_status.save
-            t.rollback_and_return ServiceResponse.error(
+            t.rollback_and_return! ServiceResponse.error(
               message: 'Failed to save runtime status',
               error_code: :invalid_runtime_status,
               details: db_status.errors

db/migrate/20251216161818_add_detailed_runtime_status.rb

@@ -11,7 +11,7 @@ def change
       t.integer :status_type, null: false, default: 0
       t.datetime_with_timezone :last_heartbeat
       t.text :identifier, null: false
-      t.text :feature_set, array: true, default: [], null: false
+      t.text :features, array: true, default: [], null: false
 
       t.timestamps_with_timezone
     end

db/structure.sql

@@ -748,7 +748,7 @@ CREATE TABLE runtime_statuses (
     status_type integer DEFAULT 0 NOT NULL,
     last_heartbeat timestamp with time zone,
     identifier text NOT NULL,
-    feature_set text[] DEFAULT '{}'::text[] NOT NULL,
+    features text[] DEFAULT '{}'::text[] NOT NULL,
     created_at timestamp with time zone NOT NULL,
     updated_at timestamp with time zone NOT NULL
 );

lib/sagittarius/middleware/grpc/logger.rb

@@ -31,6 +31,7 @@ def execute(method:, **_)
           end_time = Sagittarius::Utils.monotonic_time
           payload = log_payload(method, code, end_time - start_time, exception)
 
+          p exception.backtrace
           if exception
             logger.error(**payload, stack: exception.backtrace)
           else

spec/factories/runtime_status.rb

@@ -6,7 +6,7 @@
     last_heartbeat { Time.zone.today }
     status_type { :adapter }
     identifier { SecureRandom.uuid }
-    feature_set { [] }
+    features { [] }
     runtime
   end
 end

spec/requests/grpc/sagittarius/runtime_status_update_service_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'sagittarius.RuntimeStatusServiceRuntimeFunctionDefinitionService', :need_grpc_server do
+  include GrpcHelpers
+
+  let(:stub) { create_stub Tucana::Sagittarius::RuntimeStatusService }
+
+  describe 'Update' do
+    let(:runtime) { create(:runtime) }
+    let(:to_update_status) do
+      Tucana::Shared::AdapterRuntimeStatus.new(
+        status: Tucana::Shared::RuntimeStatus::RUNNING,
+        timestamp: Time.now.to_i.to_s,
+        identifier: 'adapter_status_1',
+        features: ['http'],
+        configurations: [
+          Tucana::Shared::AdapterConfiguration.new(
+            endpoint: 'http://localhost:3000'
+          )
+        ]
+      )
+    end
+
+    let(:message) do
+      Tucana::Sagittarius::RuntimeStatusUpdateRequest.new(adapter_runtime_status: to_update_status)
+    end
+
+    it 'creates a correct functions' do
+      expect(stub.update(message, authorization(runtime)).success).to be(true)
+      db_status = RuntimeStatus.last
+      expect(db_status.runtime).to eq(runtime)
+      expect(db_status.identifier).to eq('adapter_status_1')
+      expect(db_status.status_type).to eq('adapter')
+      expect(db_status.status).to eq('running')
+      expect(db_status.features).to eq(['http'])
+      expect(db_status.runtime_status_configurations.count).to eq(1)
+      expect(db_status.runtime_status_configurations.first.endpoint).to eq('http://localhost:3000')
+    end
+
+    context 'when old configuration exists before' do
+      before do
+        create(:runtime_status_configuration, endpoint: 'http://old-endpoint.com',
+                                              runtime_status: create(:runtime_status,
+                                                                     runtime: runtime,
+                                                                     identifier: 'adapter_status_1'))
+      end
+
+      it 'updates the existing configuration' do
+        expect(stub.update(message, authorization(runtime)).success).to be(true)
+        expect(RuntimeStatusConfiguration.count).to eq(1)
+        config = RuntimeStatusConfiguration.last
+        expect(config.endpoint).to eq('http://localhost:3000')
+      end
+    end
+  end
+end