feat: wip function identifier change+

Author: raphael-goetz

app/grpc/execution_handler.rb

@@ -74,7 +74,10 @@ def handle_execution_result(execution_result, runtime_id)
       execution_identifier: execution_result.execution_identifier
     )
 
-    response = Namespaces::Projects::Flows::PersistExecutionResultService.new(execution_result).execute
+    response = Namespaces::Projects::Flows::PersistExecutionResultService.new(
+      execution_result,
+      runtime_id: runtime_id
+    ).execute
     return if response.success?
 
     logger.error(

app/services/namespaces/projects/flows/persist_execution_result_service.rb

@@ -6,10 +6,11 @@ module Flows
       class PersistExecutionResultService
         include Code0::ZeroTrack::Loggable
 
-        attr_reader :grpc_result
+        attr_reader :grpc_result, :runtime_id
 
-        def initialize(grpc_result)
+        def initialize(grpc_result, runtime_id: nil)
           @grpc_result = grpc_result
+          @runtime_id = runtime_id
         end
 
         def execute
@@ -56,7 +57,7 @@ def build_node_results(result)
               started_at: node_result.started_at,
               finished_at: node_result.finished_at,
               node_function: node_function_for(node_result),
-              function_definition: function_definition_for(node_result)
+              function_definition: function_definition_for(node_result, result.flow)
             )
 
             assign_result(node_record, node_result)
@@ -79,10 +80,19 @@ def node_function_for(node_result)
           NodeFunction.find_by(id: node_result.node_id)
         end
 
-        def function_definition_for(node_result)
-          return unless node_result.id == :function_id
+        def function_definition_for(node_result, flow)
+          return unless node_result.id == :function_identifier
 
-          FunctionDefinition.find_by(id: node_result.function_id)
+          runtime = runtime_for(flow)
+          return if runtime.nil?
+
+          FunctionDefinition.find_by(runtime: runtime, identifier: node_result.function_identifier)
+        end
+
+        def runtime_for(flow)
+          return Runtime.find_by(id: runtime_id) if runtime_id.present?
+
+          flow.project.primary_runtime || flow.flow_type.runtime
         end
 
         def assign_result(record, grpc_record)

spec/services/namespaces/projects/flows/persist_execution_result_service_spec.rb

@@ -3,10 +3,11 @@
 require 'rails_helper'
 
 RSpec.describe Namespaces::Projects::Flows::PersistExecutionResultService do
-  subject(:service_response) { described_class.new(grpc_result).execute }
+  subject(:service_response) { described_class.new(grpc_result, runtime_id: runtime_id).execute }
 
   let(:flow) { create(:flow) }
   let(:node_function) { create(:node_function, flow: flow) }
+  let(:runtime_id) { nil }
   let(:started_at) { 1_780_430_000_000_000 }
   let(:finished_at) { 1_780_430_002_000_000 }
 
@@ -168,6 +169,10 @@
 
   context 'when a node execution result targets a function definition' do
     let(:function_definition) { create(:function_definition) }
+    let!(:other_function_definition) do
+      create(:function_definition, identifier: function_definition.identifier)
+    end
+
     let(:grpc_result) do
       Tucana::Shared::ExecutionResult.new(
         execution_identifier: 'execution-identifier',
@@ -178,7 +183,7 @@
         success: Tucana::Shared::Value.from_ruby('result' => true),
         node_execution_results: [
           Tucana::Shared::NodeExecutionResult.new(
-            function_id: function_definition.id,
+            function_identifier: function_definition.identifier,
             started_at: started_at,
             finished_at: finished_at,
             success: Tucana::Shared::Value.from_ruby('function' => 'ok')
@@ -187,6 +192,10 @@
       )
     end
 
+    before do
+      flow.project.update!(primary_runtime: function_definition.runtime)
+    end
+
     it 'persists the function definition as the execution target' do
       expect(service_response).to be_success
 
@@ -196,6 +205,18 @@
         success: { 'function' => 'ok' }
       )
     end
+
+    context 'when a runtime id is provided' do
+      let(:runtime_id) { other_function_definition.runtime_id }
+
+      it 'looks up the function definition in the connected runtime' do
+        expect(service_response).to be_success
+
+        expect(service_response.payload.node_results.sole).to have_attributes(
+          function_definition: other_function_definition
+        )
+      end
+    end
   end
 
   context 'when the result is an error' do