Revert "SERVER-65459 Construct NamespaceString using tenantId on the OpMsgRequest during command parsing for IDL defined commands"

This reverts commit c340d5a7a891758510728997c839f8e8d7e5eaa0.

6 files changed, 48 insertions, 63 deletions

diff --git a/buildscripts/idl/idl/ast.py b/buildscripts/idl/idl/ast.py
index 63cb4502039..d86ccbbb257 100644
--- a/buildscripts/idl/idl/ast.py
+++ b/buildscripts/idl/idl/ast.py
@@ -113,7 +113,6 @@ class Type(common.SourceLocation):
         # A variant can have at most one alternative type which is a struct. Otherwise, if we saw
         # a sub-object while parsing BSON, we wouldn't know which struct to interpret it as.
         self.variant_struct_type = None  # type: Type
-        self.deserialize_with_tenant = False  # type: bool
         super(Type, self).__init__(file_name, line, column)
 
 
diff --git a/buildscripts/idl/idl/binder.py b/buildscripts/idl/idl/binder.py
index 56cb2a53636..c90019b2191 100644
--- a/buildscripts/idl/idl/binder.py
+++ b/buildscripts/idl/idl/binder.py
@@ -982,7 +982,6 @@ def _bind_type(idltype):
     ast_type.bindata_subtype = idltype.bindata_subtype
     ast_type.serializer = _normalize_method_name(idltype.cpp_type, idltype.serializer)
     ast_type.deserializer = _normalize_method_name(idltype.cpp_type, idltype.deserializer)
-    ast_type.deserialize_with_tenant = idltype.deserialize_with_tenant
     return ast_type
 
 
diff --git a/buildscripts/idl/idl/generator.py b/buildscripts/idl/idl/generator.py
index b03a74966ae..2c2d3b9373d 100644
--- a/buildscripts/idl/idl/generator.py
+++ b/buildscripts/idl/idl/generator.py
@@ -1149,16 +1149,14 @@ class _CppSourceFileWriter(_CppFileWriterBase):
     # pylint: disable=too-many-public-methods
     """C++ .cpp File writer."""
 
-    _EMPTY_TENANT = "boost::optional<mongo::TenantId>{}"
-
     def __init__(self, indented_writer, target_arch):
         # type: (writer.IndentedTextWriter, str) -> None
         """Create a C++ .cpp file code writer."""
         self._target_arch = target_arch
         super(_CppSourceFileWriter, self).__init__(indented_writer)
 
-    def _gen_field_deserializer_expression(self, element_name, field, ast_type, tenant):
-        # type: (str, ast.Field, ast.Type, str) -> str
+    def _gen_field_deserializer_expression(self, element_name, field, ast_type):
+        # type: (str, ast.Field, ast.Type) -> str
         # pylint: disable=invalid-name,too-many-return-statements
         """
         Generate the C++ deserializer piece for a field.
@@ -1197,14 +1195,8 @@ class _CppSourceFileWriter(_CppFileWriterBase):
                                             (_get_field_constant_name(field)))
                     return common.template_args("${method_name}(tempContext, ${expression})",
                                                 method_name=method_name, expression=expression)
-
-                if ast_type.deserialize_with_tenant:
-                    return common.template_args("${method_name}(${tenant}, ${expression})",
-                                                method_name=method_name, tenant=tenant,
-                                                expression=expression)
-                else:
-                    return common.template_args("${method_name}(${expression})",
-                                                method_name=method_name, expression=expression)
+                return common.template_args("${method_name}(${expression})",
+                                            method_name=method_name, expression=expression)
 
             # BSONObjects are allowed to be pass through without deserialization
             assert ast_type.bson_serialization_type in [['object'], ['array']]
@@ -1214,13 +1206,10 @@ class _CppSourceFileWriter(_CppFileWriterBase):
         # Class Class::method(const BSONElement& value)
         method_name = writer.get_method_name_from_qualified_method_name(ast_type.deserializer)
 
-        if ast_type.deserialize_with_tenant:
-            return '%s(%s, %s)' % (method_name, tenant, element_name)
-        else:
-            return '%s(%s)' % (method_name, element_name)
+        return '%s(%s)' % (method_name, element_name)
 
-    def _gen_array_deserializer(self, field, bson_element, ast_type, tenant):
-        # type: (ast.Field, str, ast.Type, str) -> None
+    def _gen_array_deserializer(self, field, bson_element, ast_type):
+        # type: (ast.Field, str, ast.Type) -> None
         """Generate the C++ deserializer piece for an array field."""
         assert ast_type.is_array
         cpp_type_info = cpp_types.get_cpp_type_from_cpp_type_name(field, ast_type.cpp_type, True)
@@ -1253,7 +1242,7 @@ class _CppSourceFileWriter(_CppFileWriterBase):
 
                 with self._predicate(_get_bson_type_check('arrayElement', 'arrayCtxt', ast_type)):
                     array_value = self._gen_field_deserializer_expression(
-                        'arrayElement', field, ast_type, tenant)
+                        'arrayElement', field, ast_type)
                     self._writer.write_line('values.emplace_back(%s);' % (array_value))
 
             with self._block('else {', '}'):
@@ -1275,8 +1264,8 @@ class _CppSourceFileWriter(_CppFileWriterBase):
         else:
             self._writer.write_line('%s = std::move(values);' % (_get_field_member_name(field)))
 
-    def _gen_variant_deserializer(self, field, bson_element, tenant):
-        # type: (ast.Field, str, str) -> None
+    def _gen_variant_deserializer(self, field, bson_element):
+        # type: (ast.Field, str) -> None
         # pylint: disable=too-many-statements
         """Generate the C++ deserializer piece for a variant field."""
         self._writer.write_empty_line()
@@ -1291,7 +1280,7 @@ class _CppSourceFileWriter(_CppFileWriterBase):
             self._writer.indent()
             with self._predicate('%s.Obj().isEmpty()' % (bson_element, )):
                 # Can't determine element type of an empty array, use the first array type.
-                self._gen_array_deserializer(field, bson_element, array_types[0], tenant)
+                self._gen_array_deserializer(field, bson_element, array_types[0])
 
             with self._block('else {', '}'):
                 self._writer.write_line(
@@ -1304,7 +1293,7 @@ class _CppSourceFileWriter(_CppFileWriterBase):
                         self._writer.write_line('case %s:' % (bson.cpp_bson_type_name(bson_type), ))
                     # Each copy of the array deserialization code gets an anonymous block.
                     with self._block('{', '}'):
-                        self._gen_array_deserializer(field, bson_element, array_type, tenant)
+                        self._gen_array_deserializer(field, bson_element, array_type)
                         self._writer.write_line('break;')
 
                 self._writer.write_line('default:')
@@ -1328,7 +1317,7 @@ class _CppSourceFileWriter(_CppFileWriterBase):
                 self._writer.write_line('case %s:' % (bson.cpp_bson_type_name(bson_type), ))
                 with self._block('{', '}'):
                     self.gen_field_deserializer(field, scalar_type, "bsonObject", bson_element,
-                                                None, tenant, check_type=False)
+                                                None, check_type=False)
                     self._writer.write_line('break;')
 
         if field.type.variant_struct_type:
@@ -1368,8 +1357,8 @@ class _CppSourceFileWriter(_CppFileWriterBase):
                 self._writer.write_line('%s = true;' % (_get_has_field_member_name(field)))
 
     def gen_field_deserializer(self, field, field_type, bson_object, bson_element,
-                               field_usage_check, tenant, is_command_field=False, check_type=True):
-        # type: (ast.Field, ast.Type, str, str, _FieldUsageCheckerBase, str, bool, bool) -> None
+                               field_usage_check, is_command_field=False, check_type=True):
+        # type: (ast.Field, ast.Type, str, str, _FieldUsageCheckerBase, bool, bool) -> None
         """Generate the C++ deserializer piece for a field.
 
         If field_type is scalar and check_type is True (the default), generate type-checking code.
@@ -1380,12 +1369,12 @@ class _CppSourceFileWriter(_CppFileWriterBase):
             predicate = "MONGO_likely(ctxt.checkAndAssertType(%s, Array))" % (bson_element)
             with self._predicate(predicate):
                 self._gen_usage_check(field, bson_element, field_usage_check)
-            self._gen_array_deserializer(field, bson_element, field_type, tenant)
+            self._gen_array_deserializer(field, bson_element, field_type)
             return
 
         elif field_type.is_variant:
             self._gen_usage_check(field, bson_element, field_usage_check)
-            self._gen_variant_deserializer(field, bson_element, tenant)
+            self._gen_variant_deserializer(field, bson_element)
             return
 
         def validate_and_assign_or_uassert(field, expression):
@@ -1428,7 +1417,7 @@ class _CppSourceFileWriter(_CppFileWriterBase):
                 self._gen_usage_check(field, bson_element, field_usage_check)
 
                 object_value = self._gen_field_deserializer_expression(
-                    bson_element, field, field_type, tenant)
+                    bson_element, field, field_type)
                 if field.chained_struct_field:
                     if field.optional:
                         # We must invoke the boost::optional constructor when setting optional view
@@ -1579,23 +1568,23 @@ class _CppSourceFileWriter(_CppFileWriterBase):
 
         self._writer.write_empty_line()
 
-    def _gen_command_deserializer(self, struct, bson_object, tenant=_EMPTY_TENANT):
-        # type: (ast.Struct, str, str) -> None
+    def _gen_command_deserializer(self, struct, bson_object):
+        # type: (ast.Struct, str) -> None
         """Generate the command field deserializer."""
 
         if isinstance(struct, ast.Command) and struct.command_field:
             with self._block('{', '}'):
                 self.gen_field_deserializer(struct.command_field, struct.command_field.type,
-                                            bson_object, "commandElement", None, tenant,
-                                            is_command_field=True, check_type=True)
+                                            bson_object, "commandElement", None,
+                                            is_command_field=True)
         else:
             struct_type_info = struct_types.get_struct_info(struct)
 
             # Generate namespace check now that "$db" has been read or defaulted
-            struct_type_info.gen_namespace_check(self._writer, tenant, "_dbName", "commandElement")
+            struct_type_info.gen_namespace_check(self._writer, "_dbName", "commandElement")
 
-    def _gen_fields_deserializer_common(self, struct, bson_object, tenant=_EMPTY_TENANT):
-        # type: (ast.Struct, str, str) -> _FieldUsageCheckerBase
+    def _gen_fields_deserializer_common(self, struct, bson_object):
+        # type: (ast.Struct, str) -> _FieldUsageCheckerBase
         """Generate the C++ code to deserialize list of fields."""
         # pylint: disable=too-many-branches
         field_usage_check = _get_field_usage_checker(self._writer, struct)
@@ -1638,7 +1627,7 @@ class _CppSourceFileWriter(_CppFileWriterBase):
                         self._writer.write_line('// ignore field')
                     else:
                         self.gen_field_deserializer(field, field.type, bson_object, "element",
-                                                    field_usage_check, tenant)
+                                                    field_usage_check)
 
                 if first_field:
                     first_field = False
@@ -1671,7 +1660,7 @@ class _CppSourceFileWriter(_CppFileWriterBase):
                 continue
 
             # Simply generate deserializers since these are all 'any' types
-            self.gen_field_deserializer(field, field.type, bson_object, "element", None, tenant)
+            self.gen_field_deserializer(field, field.type, bson_object, "element", None)
             self._writer.write_empty_line()
 
         self._writer.write_empty_line()
@@ -1817,8 +1806,7 @@ class _CppSourceFileWriter(_CppFileWriterBase):
         with self._block('%s {' % (func_def), '}'):
 
             # Deserialize all the fields
-            field_usage_check = self._gen_fields_deserializer_common(
-                struct, "request.body", "request.getValidatedTenantId()")
+            field_usage_check = self._gen_fields_deserializer_common(struct, "request.body")
 
             # Iterate through the document sequences if we have any
             has_doc_sequence = len(
@@ -1867,7 +1855,7 @@ class _CppSourceFileWriter(_CppFileWriterBase):
             field_usage_check.add_final_checks()
             self._writer.write_empty_line()
 
-            self._gen_command_deserializer(struct, "request.body", "request.getValidatedTenantId()")
+            self._gen_command_deserializer(struct, "request.body")
 
     def _gen_serializer_method_custom(self, field):
         # type: (ast.Field) -> None
diff --git a/buildscripts/idl/idl/parser.py b/buildscripts/idl/idl/parser.py
index d62dd69bb6e..2d9925db500 100644
--- a/buildscripts/idl/idl/parser.py
+++ b/buildscripts/idl/idl/parser.py
@@ -253,7 +253,6 @@ def _parse_type(ctxt, spec, name, node):
             "bindata_subtype": _RuleDesc('scalar'),
             "serializer": _RuleDesc('scalar'),
             "deserializer": _RuleDesc('scalar'),
-            "deserialize_with_tenant": _RuleDesc('bool_scalar'),
             "default": _RuleDesc('scalar'),
         })
 
diff --git a/buildscripts/idl/idl/struct_types.py b/buildscripts/idl/idl/struct_types.py
index 07e41af11b5..b3b0df60532 100644
--- a/buildscripts/idl/idl/struct_types.py
+++ b/buildscripts/idl/idl/struct_types.py
@@ -229,8 +229,8 @@ class StructTypeInfoBase(object, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def gen_namespace_check(self, indented_writer, tenant, db_name, element):
-        # type: (writer.IndentedTextWriter, str, str, str) -> None
+    def gen_namespace_check(self, indented_writer, db_name, element):
+        # type: (writer.IndentedTextWriter, str, str) -> None
         """Generate the namespace check predicate for a command."""
         pass
 
@@ -301,8 +301,8 @@ class _StructTypeInfo(StructTypeInfoBase):
         # type: (writer.IndentedTextWriter) -> None
         pass
 
-    def gen_namespace_check(self, indented_writer, tenant, db_name, element):
-        # type: (writer.IndentedTextWriter, str, str, str) -> None
+    def gen_namespace_check(self, indented_writer, db_name, element):
+        # type: (writer.IndentedTextWriter, str, str) -> None
         pass
 
 
@@ -364,8 +364,8 @@ class _IgnoredCommandTypeInfo(_CommandBaseTypeInfo):
         # type: (writer.IndentedTextWriter) -> None
         indented_writer.write_line('builder->append("%s"_sd, 1);' % (self._command.name))
 
-    def gen_namespace_check(self, indented_writer, tenant, db_name, element):
-        # type: (writer.IndentedTextWriter, str, str, str) -> None
+    def gen_namespace_check(self, indented_writer, db_name, element):
+        # type: (writer.IndentedTextWriter, str, str) -> None
         pass
 
 
@@ -437,8 +437,8 @@ class _CommandFromType(_CommandBaseTypeInfo):
         # type: (writer.IndentedTextWriter) -> None
         raise NotImplementedError
 
-    def gen_namespace_check(self, indented_writer, tenant, db_name, element):
-        # type: (writer.IndentedTextWriter, str, str, str) -> None
+    def gen_namespace_check(self, indented_writer, db_name, element):
+        # type: (writer.IndentedTextWriter, str, str) -> None
         # TODO: should the name of the first element be validated??
         raise NotImplementedError
 
@@ -512,14 +512,16 @@ class _CommandWithNamespaceTypeInfo(_CommandBaseTypeInfo):
                 'builder->append("%s"_sd, _nss.coll());' % (self._command.name))
         indented_writer.write_empty_line()
 
-    def gen_namespace_check(self, indented_writer, tenant, db_name, element):
-        # type: (writer.IndentedTextWriter, str, str, str) -> None
+    def gen_namespace_check(self, indented_writer, db_name, element):
+        # type: (writer.IndentedTextWriter, str, str) -> None
         # TODO: should the name of the first element be validated??
         indented_writer.write_line('invariant(_nss.isEmpty());')
-        indented_writer.write_line('DatabaseName dbName(%s, %s);' % (tenant, db_name))
-        allow_global = 'true' if self._struct.allow_global_collection_name else 'false'
-        indented_writer.write_line('_nss = ctxt.parseNSCollectionRequired(%s, %s, %s);' %
-                                   ('dbName', element, allow_global))
+        if self._struct.allow_global_collection_name:
+            indented_writer.write_line(
+                '_nss = ctxt.parseNSCollectionRequired(%s, %s, true);' % (db_name, element))
+        else:
+            indented_writer.write_line(
+                '_nss = ctxt.parseNSCollectionRequired(%s, %s, false);' % (db_name, element))
 
 
 class _CommandWithUUIDNamespaceTypeInfo(_CommandBaseTypeInfo):
@@ -587,11 +589,10 @@ class _CommandWithUUIDNamespaceTypeInfo(_CommandBaseTypeInfo):
         indented_writer.write_line('_nssOrUUID.serialize(builder, "%s"_sd);' % (self._command.name))
         indented_writer.write_empty_line()
 
-    def gen_namespace_check(self, indented_writer, tenant, db_name, element):
-        # type: (writer.IndentedTextWriter, str, str, str) -> None
-        indented_writer.write_line('DatabaseName dbName(%s, %s);' % (tenant, db_name))
+    def gen_namespace_check(self, indented_writer, db_name, element):
+        # type: (writer.IndentedTextWriter, str, str) -> None
         indented_writer.write_line('invariant(_nssOrUUID.nss() || _nssOrUUID.uuid());')
-        indented_writer.write_line('_nssOrUUID = ctxt.parseNsOrUUID(%s, %s);' % ('dbName', element))
+        indented_writer.write_line('_nssOrUUID = ctxt.parseNsOrUUID(%s, %s);' % (db_name, element))
 
 
 def get_struct_info(struct):
diff --git a/buildscripts/idl/idl/syntax.py b/buildscripts/idl/idl/syntax.py
index 79bfdd002be..0cfcf88e73d 100644
--- a/buildscripts/idl/idl/syntax.py
+++ b/buildscripts/idl/idl/syntax.py
@@ -370,7 +370,6 @@ class Type(common.SourceLocation):
         self.serializer = None  # type: str
         self.deserializer = None  # type: str
         self.description = None  # type: str
-        self.deserialize_with_tenant = False  # type: bool
         self.default = None  # type: str
 
         super(Type, self).__init__(file_name, line, column)