code: def _cache_morlist_raw(self, instance):
          
          i_key = self._instance_key(instance)
          self.log.debug("Caching the morlist for vcenter instance {}".format(i_key))
  
          # If the queue is not completely empty, don't do anything
          for resource_type in RESOURCE_TYPE_METRICS:
              if self.mor_objects_queue.contains(i_key) and self.mor_objects_queue.size(i_key, resource_type):
                  last = self.cache_config.get_last(CacheConfig.Morlist, i_key)
                  self.log.debug(
                      "Skipping morlist collection: the objects queue for the "
                      "resource type '{}' is still being processed "
                      "(latest refresh was {}s ago)".format(ensure_unicode(resource_type), time.time() - last)
                  )
                  return
  
          tags = ["vcenter_server:{}".format(ensure_unicode(instance.get('name')))]
          regexes = {
              'host_include': instance.get('host_include_only_regex'),
              'vm_include': instance.get('vm_include_only_regex'),
          }
          include_only_marked = is_affirmative(instance.get('include_only_marked', False))
  
          # Discover hosts and virtual machines
          server_instance = self._get_server_instance(instance)
          use_guest_hostname = is_affirmative(instance.get("use_guest_hostname", False))
          all_objs = self._get_all_objs(
              server_instance, regexes, include_only_marked, tags, use_guest_hostname=use_guest_hostname
          )
  
          self.mor_objects_queue.fill(i_key, dict(all_objs))
          self.cache_config.set_last(CacheConfig.Morlist, i_key, time.time())
docs: Fill the Mor objects queue that will be asynchronously processed later.
          Resolve the vCenter `rootFolder` and initiate hosts and virtual machines
          discovery.