code: def _serialize_to_jvm(self, data, serializer, reader_func, createRDDServer):
          
          if self._encryption_enabled:
              # with encryption, we open a server in java and send the data directly
              server = createRDDServer()
              (sock_file, _) = local_connect_and_auth(server.port(), server.secret())
              chunked_out = ChunkedStream(sock_file, 8192)
              serializer.dump_stream(data, chunked_out)
              chunked_out.close()
              # this call will block until the server has read all the data and processed it (or
              # throws an exception)
              r = server.getResult()
              return r
          else:
              # without encryption, we serialize to a file, and we read the file in java and
              # parallelize from there.
              tempFile = NamedTemporaryFile(delete=False, dir=self._temp_dir)
              try:
                  try:
                      serializer.dump_stream(data, tempFile)
                  finally:
                      tempFile.close()
                  return reader_func(tempFile.name)
              finally:
                  # we eagerily reads the file so we can delete right after.
                  os.unlink(tempFile.name)
docs: Using py4j to send a large dataset to the jvm is really slow, so we use either a file
          or a socket if we have encryption enabled.
          :param data:
          :param serializer:
          :param reader_func:  A function which takes a filename and reads in the data in the jvm and
                  returns a JavaRDD. Only used when encryption is disabled.
          :param createRDDServer:  A function which creates a PythonRDDServer in the jvm to
                 accept the serialized data, for use when encryption is enabled.
          :return: