pkg/flatrpc: remove executing info from execution result

We needed it in the old RPC b/c messages could have been delivered
out-of-order, so we could not receive executing info when execution
is completed. With the new RPC out-of-order delivery can't happen.

3 files changed, 35 insertions, 38 deletions

diff --git a/pkg/flatrpc/flatrpc.fbs b/pkg/flatrpc/flatrpc.fbs
index cebc306a4..01cd8190d 100644
--- a/pkg/flatrpc/flatrpc.fbs
+++ b/pkg/flatrpc/flatrpc.fbs
@@ -207,8 +207,8 @@ table ProgInfoRaw {
 
 // Result of executing a test program.
 table ExecResultRaw {
-	executing	:ExecutingMessageRaw;
-	output		:[uint8];
-	error		:string;
-	info		:ProgInfoRaw;
+	id			:int64;
+	output			:[uint8];
+	error			:string;
+	info			:ProgInfoRaw;
 }
diff --git a/pkg/flatrpc/flatrpc.go b/pkg/flatrpc/flatrpc.go
index ad1be7bc7..74ccacef8 100644
--- a/pkg/flatrpc/flatrpc.go
+++ b/pkg/flatrpc/flatrpc.go
@@ -2710,17 +2710,16 @@ func ProgInfoRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 }
 
 type ExecResultRawT struct {
-	Executing *ExecutingMessageRawT `json:"executing"`
-	Output    []byte                `json:"output"`
-	Error     string                `json:"error"`
-	Info      *ProgInfoRawT         `json:"info"`
+	Id     int64         `json:"id"`
+	Output []byte        `json:"output"`
+	Error  string        `json:"error"`
+	Info   *ProgInfoRawT `json:"info"`
 }
 
 func (t *ExecResultRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 	if t == nil {
 		return 0
 	}
-	executingOffset := t.Executing.Pack(builder)
 	outputOffset := flatbuffers.UOffsetT(0)
 	if t.Output != nil {
 		outputOffset = builder.CreateByteString(t.Output)
@@ -2728,7 +2727,7 @@ func (t *ExecResultRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT
 	errorOffset := builder.CreateString(t.Error)
 	infoOffset := t.Info.Pack(builder)
 	ExecResultRawStart(builder)
-	ExecResultRawAddExecuting(builder, executingOffset)
+	ExecResultRawAddId(builder, t.Id)
 	ExecResultRawAddOutput(builder, outputOffset)
 	ExecResultRawAddError(builder, errorOffset)
 	ExecResultRawAddInfo(builder, infoOffset)
@@ -2736,7 +2735,7 @@ func (t *ExecResultRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT
 }
 
 func (rcv *ExecResultRaw) UnPackTo(t *ExecResultRawT) {
-	t.Executing = rcv.Executing(nil).UnPack()
+	t.Id = rcv.Id()
 	t.Output = rcv.OutputBytes()
 	t.Error = string(rcv.Error())
 	t.Info = rcv.Info(nil).UnPack()
@@ -2778,17 +2777,16 @@ func (rcv *ExecResultRaw) Table() flatbuffers.Table {
 	return rcv._tab
 }
 
-func (rcv *ExecResultRaw) Executing(obj *ExecutingMessageRaw) *ExecutingMessageRaw {
+func (rcv *ExecResultRaw) Id() int64 {
 	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
 	if o != 0 {
-		x := rcv._tab.Indirect(o + rcv._tab.Pos)
-		if obj == nil {
-			obj = new(ExecutingMessageRaw)
-		}
-		obj.Init(rcv._tab.Bytes, x)
-		return obj
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
 	}
-	return nil
+	return 0
+}
+
+func (rcv *ExecResultRaw) MutateId(n int64) bool {
+	return rcv._tab.MutateInt64Slot(4, n)
 }
 
 func (rcv *ExecResultRaw) Output(j int) byte {
@@ -2849,8 +2847,8 @@ func (rcv *ExecResultRaw) Info(obj *ProgInfoRaw) *ProgInfoRaw {
 func ExecResultRawStart(builder *flatbuffers.Builder) {
 	builder.StartObject(4)
 }
-func ExecResultRawAddExecuting(builder *flatbuffers.Builder, executing flatbuffers.UOffsetT) {
-	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(executing), 0)
+func ExecResultRawAddId(builder *flatbuffers.Builder, id int64) {
+	builder.PrependInt64Slot(0, id, 0)
 }
 func ExecResultRawAddOutput(builder *flatbuffers.Builder, output flatbuffers.UOffsetT) {
 	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(output), 0)
diff --git a/pkg/flatrpc/flatrpc.h b/pkg/flatrpc/flatrpc.h
index 205044b7e..24a4c9f1a 100644
--- a/pkg/flatrpc/flatrpc.h
+++ b/pkg/flatrpc/flatrpc.h
@@ -2061,7 +2061,7 @@ flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRaw(flatbuffers::FlatBufferBuilde
 
 struct ExecResultRawT : public flatbuffers::NativeTable {
   typedef ExecResultRaw TableType;
-  std::unique_ptr<rpc::ExecutingMessageRawT> executing{};
+  int64_t id = 0;
   std::vector<uint8_t> output{};
   std::string error{};
   std::unique_ptr<rpc::ProgInfoRawT> info{};
@@ -2075,13 +2075,13 @@ struct ExecResultRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef ExecResultRawT NativeTableType;
   typedef ExecResultRawBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_EXECUTING = 4,
+    VT_ID = 4,
     VT_OUTPUT = 6,
     VT_ERROR = 8,
     VT_INFO = 10
   };
-  const rpc::ExecutingMessageRaw *executing() const {
-    return GetPointer<const rpc::ExecutingMessageRaw *>(VT_EXECUTING);
+  int64_t id() const {
+    return GetField<int64_t>(VT_ID, 0);
   }
   const flatbuffers::Vector<uint8_t> *output() const {
     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_OUTPUT);
@@ -2094,8 +2094,7 @@ struct ExecResultRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_EXECUTING) &&
-           verifier.VerifyTable(executing()) &&
+           VerifyField<int64_t>(verifier, VT_ID, 8) &&
            VerifyOffset(verifier, VT_OUTPUT) &&
            verifier.VerifyVector(output()) &&
            VerifyOffset(verifier, VT_ERROR) &&
@@ -2113,8 +2112,8 @@ struct ExecResultRawBuilder {
   typedef ExecResultRaw Table;
   flatbuffers::FlatBufferBuilder &fbb_;
   flatbuffers::uoffset_t start_;
-  void add_executing(flatbuffers::Offset<rpc::ExecutingMessageRaw> executing) {
-    fbb_.AddOffset(ExecResultRaw::VT_EXECUTING, executing);
+  void add_id(int64_t id) {
+    fbb_.AddElement<int64_t>(ExecResultRaw::VT_ID, id, 0);
   }
   void add_output(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output) {
     fbb_.AddOffset(ExecResultRaw::VT_OUTPUT, output);
@@ -2138,21 +2137,21 @@ struct ExecResultRawBuilder {
 
 inline flatbuffers::Offset<ExecResultRaw> CreateExecResultRaw(
     flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<rpc::ExecutingMessageRaw> executing = 0,
+    int64_t id = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output = 0,
     flatbuffers::Offset<flatbuffers::String> error = 0,
     flatbuffers::Offset<rpc::ProgInfoRaw> info = 0) {
   ExecResultRawBuilder builder_(_fbb);
+  builder_.add_id(id);
   builder_.add_info(info);
   builder_.add_error(error);
   builder_.add_output(output);
-  builder_.add_executing(executing);
   return builder_.Finish();
 }
 
 inline flatbuffers::Offset<ExecResultRaw> CreateExecResultRawDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<rpc::ExecutingMessageRaw> executing = 0,
+    int64_t id = 0,
     const std::vector<uint8_t> *output = nullptr,
     const char *error = nullptr,
     flatbuffers::Offset<rpc::ProgInfoRaw> info = 0) {
@@ -2160,7 +2159,7 @@ inline flatbuffers::Offset<ExecResultRaw> CreateExecResultRawDirect(
   auto error__ = error ? _fbb.CreateString(error) : 0;
   return rpc::CreateExecResultRaw(
       _fbb,
-      executing,
+      id,
       output__,
       error__,
       info);
@@ -2704,14 +2703,14 @@ inline flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRaw(flatbuffers::FlatBuffe
 }
 
 inline ExecResultRawT::ExecResultRawT(const ExecResultRawT &o)
-      : executing((o.executing) ? new rpc::ExecutingMessageRawT(*o.executing) : nullptr),
+      : id(o.id),
         output(o.output),
         error(o.error),
         info((o.info) ? new rpc::ProgInfoRawT(*o.info) : nullptr) {
 }
 
 inline ExecResultRawT &ExecResultRawT::operator=(ExecResultRawT o) FLATBUFFERS_NOEXCEPT {
-  std::swap(executing, o.executing);
+  std::swap(id, o.id);
   std::swap(output, o.output);
   std::swap(error, o.error);
   std::swap(info, o.info);
@@ -2727,7 +2726,7 @@ inline ExecResultRawT *ExecResultRaw::UnPack(const flatbuffers::resolver_functio
 inline void ExecResultRaw::UnPackTo(ExecResultRawT *_o, const flatbuffers::resolver_function_t *_resolver) const {
   (void)_o;
   (void)_resolver;
-  { auto _e = executing(); if (_e) _o->executing = std::unique_ptr<rpc::ExecutingMessageRawT>(_e->UnPack(_resolver)); }
+  { auto _e = id(); _o->id = _e; }
   { auto _e = output(); if (_e) { _o->output.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->output.begin()); } }
   { auto _e = error(); if (_e) _o->error = _e->str(); }
   { auto _e = info(); if (_e) _o->info = std::unique_ptr<rpc::ProgInfoRawT>(_e->UnPack(_resolver)); }
@@ -2741,13 +2740,13 @@ inline flatbuffers::Offset<ExecResultRaw> CreateExecResultRaw(flatbuffers::FlatB
   (void)_rehasher;
   (void)_o;
   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExecResultRawT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
-  auto _executing = _o->executing ? CreateExecutingMessageRaw(_fbb, _o->executing.get(), _rehasher) : 0;
+  auto _id = _o->id;
   auto _output = _o->output.size() ? _fbb.CreateVector(_o->output) : 0;
   auto _error = _o->error.empty() ? 0 : _fbb.CreateString(_o->error);
   auto _info = _o->info ? CreateProgInfoRaw(_fbb, _o->info.get(), _rehasher) : 0;
   return rpc::CreateExecResultRaw(
       _fbb,
-      _executing,
+      _id,
       _output,
       _error,
       _info);