return ((Smb2ReadRequest) message).getReadLength() > 1048576; // 1MB
        }
        if (message instanceof Smb2WriteRequest) {
            // Data length not accessible, assume large writes for now
            return true;
        }
        return false;
    }

    private boolean isMetadataOperation(CommonServerMessageBlock message) {

        final int result = copy(url, "UTF-8", writer);
        assertThat(result, is(urlString.length()));
        assertThat(writer.toString(), is(urlString));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testFileToWriter() throws Exception {
        final int result = copy(inputFile, "UTF-8", writer);
        assertThat(result, is(urlString.length()));

    setLevel(Level.HEADERS)
    server.enqueue(MockResponse())
    val body: RequestBody =
      object : RequestBody() {
        override fun contentType() = PLAIN

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("Hi!")
        }
      }
    val response = client.newCall(request().post(body).build()).execute()
    response.body.close()
    applicationLogs

			healthy := erasureSetUpCount[poolIdx][setIdx].online >= poolWriteQuorums[poolIdx]
			if !healthy && !opts.NoLogging {
				storageLogIf(logger.SetReqInfo(ctx, reqInfo),
					fmt.Errorf("Write quorum could not be established on pool: %d, set: %d, expected write quorum: %d, drives-online: %d",
						poolIdx, setIdx, poolWriteQuorums[poolIdx], erasureSetUpCount[poolIdx][setIdx].online), logger.FatalKind)
			}

            } catch (final Exception e) {
                logger.warn("Failed to insert: {}", clickLogList, e);
            }
        }
    }

    /**
     * Writes a search log event.
     *
     * @param event The search log event.
     */
    public void writeSearchLogEvent(final SearchLogEvent event) {
        try {

`UploadFile` has the following `async` methods. They all call the corresponding file methods underneath (using the internal `SpooledTemporaryFile`).

* `write(data)`: Writes `data` (`str` or `bytes`) to the file.
* `read(size)`: Reads `size` (`int`) bytes/characters of the file.
* `seek(offset)`: Goes to the byte position `offset` (`int`) in the file.

    override fun contentType() = delegate.contentType()

    override fun isDuplex() = true

    override fun writeTo(sink: BufferedSink) {
      executorService.schedule({
        try {
          delegate.writeTo(sink)
          sink.close()
        } catch (e: IOException) {
          throw RuntimeException(e)
        }
      }, delayMillis, TimeUnit.MILLISECONDS)

* Für HTTPS muss **der Server** über von einem **Dritten** generierte **„Zertifikate“** verfügen.
    * Diese Zertifikate werden tatsächlich vom Dritten **erworben** und nicht „generiert“.
* Zertifikate haben eine **Lebensdauer**.
    * Sie **verfallen**.
    * Und dann müssen sie vom Dritten **erneuert**, **erneut erworben** werden.
* Die Verschlüsselung der Verbindung erfolgt auf **TCP-Ebene**.

        assertArgumentNotNull("props", props);
        assertArgumentNotNull("writer", writer);

        try {
            props.store(writer, comments);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**

	} else {
		buckets, err = objectAPI.ListBuckets(ctx, BucketOptions{})
		if err != nil {
			writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
			return
		}
	}

	// Initialize a zip writer which will provide a zipped content
	// of bucket metadata
	zipWriter := zip.NewWriter(w)
	defer zipWriter.Close()

	rawDataFn := func(r io.Reader, filename string, sz int) {